Unexpected alert handling in Selenium Java - Build an Automation Script

Handle unexpected alert during form submission

Preconditions (2)

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

Step 2: Click the submit button

Step 3: If an unexpected alert appears, accept it

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

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

Automation Requirements - Selenium WebDriver with Java

Assertions Needed:

Verify the alert is present and accepted

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

Best Practices:

Use explicit waits to detect alert presence

Use try-catch to handle NoAlertPresentException

Avoid Thread.sleep; use WebDriverWait

Use By.id locator strategy for elements

Automated Solution

Selenium Java

import org.openqa.selenium.Alert;
import org.openqa.selenium.By;
import org.openqa.selenium.NoAlertPresentException;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.support.ui.ExpectedConditions;
import org.openqa.selenium.support.ui.WebDriverWait;

import java.time.Duration;

public class UnexpectedAlertHandlingTest {
    public static void main(String[] args) {
        System.setProperty("webdriver.chrome.driver", "path/to/chromedriver");
        WebDriver driver = new ChromeDriver();
        WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));

        try {
            // Navigate to form page
            driver.get("https://example.com/form");

            // Enter username
            WebElement usernameInput = wait.until(ExpectedConditions.elementToBeClickable(By.id("username")));
            usernameInput.sendKeys("testuser");

            // Click submit button
            WebElement submitBtn = driver.findElement(By.id("submitBtn"));
            submitBtn.click();

            // Wait briefly for alert presence
            try {
                wait.until(ExpectedConditions.alertIsPresent());
                Alert alert = driver.switchTo().alert();
                alert.accept();
            } catch (NoAlertPresentException e) {
                // No alert appeared, continue
            }

            // Verify URL changed to success page
            wait.until(ExpectedConditions.urlToBe("https://example.com/form-success"));
            String currentUrl = driver.getCurrentUrl();
            if (!"https://example.com/form-success".equals(currentUrl)) {
                throw new AssertionError("Expected URL to be https://example.com/form-success but was " + currentUrl);
            }

            System.out.println("Test passed: Unexpected alert handled and success page loaded.");

        } finally {
            driver.quit();
        }
    }
}

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

First, it opens the form page and waits until the username input is clickable, then enters 'testuser'.

Next, it clicks the submit button.

After clicking, it waits explicitly for an alert to appear. If an alert appears, it switches to it and accepts it. If no alert appears, it catches the exception and continues without failing.

Finally, it waits until the URL changes to the expected success page URL and asserts this condition. If the URL is not as expected, it throws an assertion error.

The test ends by quitting the browser.

This approach uses explicit waits and proper exception handling to manage unexpected alerts gracefully.

Common Mistakes - 4 Pitfalls

Using Thread.sleep() to wait for alert

Not handling NoAlertPresentException when switching to alert

Using brittle XPath locators for username and submit button

Not verifying the URL after alert handling

Bonus Challenge

Now add data-driven testing with 3 different usernames to submit the form and handle alerts

Show Hint

Practice

1. What is the main reason to handle unexpected alerts in Selenium tests?

easy

A. To prevent tests from stopping abruptly due to unhandled pop-ups

B. To improve the speed of test execution

C. To change the browser window size automatically

D. To log user actions during the test

Solution

1. Step 1: Understand unexpected alerts impact

   Unexpected alerts block the browser and stop test execution if not handled.

2. Step 2: Purpose of handling alerts

   Handling alerts allows the test to continue smoothly without interruption.

3. Final Answer:

   To prevent tests from stopping abruptly due to unhandled pop-ups -> Option A

4. Quick Check:

   Unexpected alerts stop tests = Handle alerts [OK]

Hint: Handle alerts to keep tests running without interruption [OK]

Common Mistakes:

• Thinking alerts only slow tests, not stop them
• Confusing alert handling with browser resizing
• Assuming alerts are for logging only

2. Which Selenium Java code snippet correctly switches to an alert and accepts it?

easy

A. driver.switchTo().alert().dismiss();

B. driver.alert().switchTo().accept();

C. driver.switchTo().alert().accept();

D. driver.switchTo().alert().sendKeys();

Solution

1. Step 1: Identify correct alert switching syntax

   The correct method to switch to alert is driver.switchTo().alert()

2. Step 2: Accept the alert

   Calling accept() on the alert confirms it and closes the pop-up.

3. Final Answer:

   driver.switchTo().alert().accept(); -> Option C

4. Quick Check:

   Switch to alert then accept = driver.switchTo().alert().accept() [OK]

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

Common Mistakes:

• Reversing switchTo() and alert() calls
• Using dismiss() instead of accept() when accept is needed
• Calling sendKeys() without parameters

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

driver.findElement(By.id("submit")).click();
driver.switchTo().alert().dismiss();
driver.findElement(By.id("next")).click();

medium

A. The alert will be accepted instead of dismissed

B. No alert handling occurs and test throws NoAlertPresentException

C. The test will fail at clicking submit due to alert presence

D. The alert will be dismissed and the next button clicked successfully

Solution

1. Step 1: Click triggers alert

   Clicking submit may cause an alert to appear unexpectedly.

2. Step 2: Alert is dismissed explicitly

   driver.switchTo().alert().dismiss() closes the alert, allowing further actions.

3. Step 3: Next element interaction

   After dismissing alert, clicking next proceeds without interruption.

4. Final Answer:

   The alert will be dismissed and the next button clicked successfully -> Option D

5. Quick Check:

   Dismiss alert then continue = success [OK]

Hint: Dismiss alert before next action to avoid test failure [OK]

Common Mistakes:

• Assuming alert auto-dismisses without code
• Expecting accept() instead of dismiss() here
• Ignoring NoAlertPresentException possibility

4. Identify the error in this code snippet handling unexpected alerts:

try {
  driver.findElement(By.id("save")).click();
} catch (NoAlertPresentException e) {
  driver.switchTo().alert().accept();
}

medium

A. NoAlertPresentException should be caught after alert handling

B. Alert handling code is inside catch for wrong exception

C. Accept() should be replaced with dismiss()

D. Try block should include alert handling, not catch

Solution

1. Step 1: Understand exception usage

   NoAlertPresentException occurs when alert is not present but code tries to switch to alert.

2. Step 2: Analyze catch block logic

   Alert handling code is wrongly placed inside catch for NoAlertPresentException, which means alert is not present.

3. Step 3: Correct approach

   Alert handling should be in try block or catch should handle different exception like UnhandledAlertException.

4. Final Answer:

   Alert handling code is inside catch for wrong exception -> Option B

5. Quick Check:

   Catch wrong exception for alert handling = error [OK]

Hint: Catch UnhandledAlertException, not NoAlertPresentException for alerts [OK]

Common Mistakes:

• Catching NoAlertPresentException to handle alert
• Placing alert.accept() inside catch for missing alert
• Confusing accept() and dismiss() usage

5. You want to write a Selenium Java method that safely clicks a button even if an unexpected alert appears. Which code snippet correctly handles this scenario?

hard

A. try {
driver.findElement(By.id("btn")).click();
} catch (UnhandledAlertException e) {
driver.switchTo().alert().accept();
driver.findElement(By.id("btn")).click();
}

B. driver.findElement(By.id("btn")).click();
driver.switchTo().alert().accept();

C. driver.switchTo().alert().accept();
driver.findElement(By.id("btn")).click();

D. try {
driver.switchTo().alert().accept();
} catch (NoAlertPresentException e) {
driver.findElement(By.id("btn")).click();
}

Solution

1. Step 1: Understand unexpected alert during click

   Clicking the button may cause an unexpected alert, throwing UnhandledAlertException.

2. Step 2: Use try-catch to handle alert and retry click

   Catch UnhandledAlertException, accept alert, then retry clicking the button to ensure action completes.

3. Step 3: Verify other options

   driver.findElement(By.id("btn")).click(); driver.switchTo().alert().accept(); and C do not handle exceptions; try { driver.switchTo().alert().accept(); } catch (NoAlertPresentException e) { driver.findElement(By.id("btn")).click(); } tries alert first which may not exist before click.

4. Final Answer:

   try { driver.findElement(By.id("btn")).click(); } catch (UnhandledAlertException e) { driver.switchTo().alert().accept(); driver.findElement(By.id("btn")).click(); } -> Option A

5. Quick Check:

   Catch alert exception, accept, retry click = safe handling [OK]

Hint: Catch alert exception, accept alert, then retry action [OK]

Common Mistakes:

• Not retrying click after alert acceptance
• Handling alert before click without exception
• Catching wrong exception types