Alert accept and dismiss in Selenium Java - Build an Automation Script

Verify alert accept and dismiss functionality

Preconditions (1)

Step 1: Click the button that triggers the alert

Step 2: Switch to the alert

Step 3: Accept the alert

Step 4: Verify the alert is closed and the expected success message is displayed

Step 5: Click the button that triggers the alert again

Step 6: Switch to the alert

Step 7: Dismiss the alert

Step 8: Verify the alert is closed and the expected cancellation message is displayed

✅ Expected Result: Alert is accepted and dismissed correctly, and the correct messages appear after each action

Automation Requirements - Selenium WebDriver with Java and TestNG

Assertions Needed:

Verify alert text before accepting or dismissing

Verify the success message after accepting the alert

Verify the cancellation message after dismissing the alert

Best Practices:

Use explicit waits to wait for alert presence

Use try-catch to handle NoAlertPresentException

Use Page Object Model to separate page actions

Use TestNG assertions for validation

Automated Solution

Selenium Java

import org.openqa.selenium.Alert;
import org.openqa.selenium.By;
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 org.testng.Assert;
import org.testng.annotations.AfterClass;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;

import java.time.Duration;

public class AlertAcceptDismissTest {
    private WebDriver driver;
    private WebDriverWait wait;

    @BeforeClass
    public void setUp() {
        // Set path to chromedriver if needed
        driver = new ChromeDriver();
        wait = new WebDriverWait(driver, Duration.ofSeconds(10));
        driver.get("https://example.com/alert-test"); // Replace with actual URL
    }

    @Test
    public void testAlertAccept() {
        WebElement alertButton = driver.findElement(By.id("alertButton"));
        alertButton.click();

        // Wait for alert to be present
        Alert alert = wait.until(ExpectedConditions.alertIsPresent());

        // Verify alert text
        String alertText = alert.getText();
        Assert.assertEquals(alertText, "Are you sure you want to proceed?", "Alert text mismatch");

        // Accept the alert
        alert.accept();

        // Verify success message displayed after accepting
        WebElement message = wait.until(ExpectedConditions.visibilityOfElementLocated(By.id("message")));
        Assert.assertEquals(message.getText(), "You accepted the alert!", "Success message mismatch after accept");
    }

    @Test(dependsOnMethods = "testAlertAccept")
    public void testAlertDismiss() {
        WebElement alertButton = driver.findElement(By.id("alertButton"));
        alertButton.click();

        Alert alert = wait.until(ExpectedConditions.alertIsPresent());

        // Verify alert text
        String alertText = alert.getText();
        Assert.assertEquals(alertText, "Are you sure you want to proceed?", "Alert text mismatch");

        // Dismiss the alert
        alert.dismiss();

        // Verify cancellation message displayed after dismissing
        WebElement message = wait.until(ExpectedConditions.visibilityOfElementLocated(By.id("message")));
        Assert.assertEquals(message.getText(), "You dismissed the alert!", "Cancellation message mismatch after dismiss");
    }

    @AfterClass
    public void tearDown() {
        if (driver != null) {
            driver.quit();
        }
    }
}

This test class uses Selenium WebDriver with TestNG to automate alert accept and dismiss actions.

setUp(): Opens the browser and navigates to the test page.

testAlertAccept(): Clicks the button to trigger alert, waits for alert, verifies alert text, accepts alert, then verifies the success message.

testAlertDismiss(): Clicks the button again, waits for alert, verifies alert text, dismisses alert, then verifies the cancellation message.

Explicit waits ensure the alert and messages are present before interacting or asserting. Assertions check the alert text and messages to confirm correct behavior. The @AfterClass method closes the browser after tests.

Common Mistakes - 4 Pitfalls

Using Thread.sleep() instead of explicit waits for alert presence

Not switching to alert before accepting or dismissing

Hardcoding alert text without verifying it

Not verifying the result message after alert action

Bonus Challenge

Now add data-driven testing with 3 different alert messages and expected results

Show Hint

Practice

1. What does the accept() method do when called on a JavaScript alert in Selenium?

easy

A. Clicks the OK button on the alert

B. Clicks the Cancel button on the alert

C. Closes the browser window

D. Throws an exception without interacting

Solution

1. Step 1: Understand alert interaction methods

   The accept() method is used to click the OK button on an alert popup.

2. Step 2: Differentiate from dismiss()

   The dismiss() method clicks Cancel, so accept() must click OK.

3. Final Answer:

   Clicks the OK button on the alert -> Option A

4. Quick Check:

   accept() = OK click [OK]

Hint: accept() clicks OK, dismiss() clicks Cancel [OK]

Common Mistakes:

• Confusing accept() with dismiss()
• Thinking accept() closes the browser
• Assuming accept() throws an exception

2. Which of the following is the correct syntax to switch to an alert and dismiss it in Selenium Java?

easy

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

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

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

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

Solution

1. Step 1: Identify the method to dismiss alert

   The method to click Cancel on an alert is dismiss().

2. Step 2: Confirm correct syntax for switching and dismissing

   The correct chain is driver.switchTo().alert().dismiss(); to dismiss the alert.

3. Final Answer:

   driver.switchTo().alert().dismiss(); -> Option A

4. Quick Check:

   dismiss() = Cancel click [OK]

Hint: Use dismiss() to cancel alerts, accept() to confirm [OK]

Common Mistakes:

• Using accept() instead of dismiss() to cancel
• Using non-existent methods like close() or cancel()
• Missing switchTo().alert() before calling dismiss()

3. Given the following code snippet, what will be printed if the alert is accepted?

driver.switchTo().alert().accept();
System.out.println("Alert handled successfully");

medium

A. UnhandledAlertException

B. Alert handled successfully

C. No output

D. Alert not found error

Solution

1. Step 1: Understand alert acceptance effect

   Calling accept() closes the alert, allowing the next line to execute.

2. Step 2: Check output after alert handling

   Since alert is accepted, System.out.println runs and prints the message.

3. Final Answer:

   Alert handled successfully -> Option B

4. Quick Check:

   accept() closes alert, next line prints [OK]

Hint: accept() lets code continue, so print runs [OK]

Common Mistakes:

• Expecting exception after accept()
• Thinking alert blocks print statement
• Confusing accept() with dismiss() effect

4. Identify the error in this Selenium Java code snippet that tries to dismiss an alert:

Alert alert = driver.switchTo().alert();
alert.accept();
alert.dismiss();

medium

A. alert.dismiss() should be alert.cancel()

B. Calling accept() before dismiss() causes an exception

C. Missing driver.switchTo() before alert()

D. Cannot call dismiss() after accept() on the same alert instance

Solution

1. Step 1: Understand alert lifecycle after accept()

   Once accept() is called, the alert is closed and no longer available.

2. Step 2: Calling dismiss() after accept() is invalid

   Trying to dismiss the same alert after accepting it causes an error because alert is gone.

3. Final Answer:

   Cannot call dismiss() after accept() on the same alert instance -> Option D

4. Quick Check:

   accept() closes alert, no dismiss() after [OK]

Hint: Alert closes after accept(), can't dismiss same alert [OK]

Common Mistakes:

• Calling dismiss() after accept() on same alert
• Assuming alert stays open after accept()
• Using non-existent cancel() method

5. You want to write a Selenium Java test that clicks Cancel on a confirmation alert only if the alert text contains the word "Delete". Which code snippet correctly implements this?

hard

A. Alert alert = driver.switchTo().alert();
if (alert.getText() == "Delete") {
alert.accept();
} else {
alert.dismiss();
}

B. Alert alert = driver.switchTo().alert();
alert.dismiss();
if (alert.getText().contains("Delete")) {
alert.accept();
}

C. Alert alert = driver.switchTo().alert();
if (alert.getText().contains("Delete")) {
alert.dismiss();
} else {
alert.accept();
}

D. Alert alert = driver.switchTo().alert();
alert.accept();
alert.dismiss();

Solution

1. Step 1: Check alert text for "Delete" substring

   Use alert.getText().contains("Delete") to detect if alert text includes "Delete".

2. Step 2: Dismiss alert if condition true, else accept

   If text contains "Delete", call dismiss() to click Cancel; otherwise, call accept().

3. Final Answer:

   Alert alert = driver.switchTo().alert(); if (alert.getText().contains("Delete")) { alert.dismiss(); } else { alert.accept(); } -> Option C

4. Quick Check:

   Use contains() and dismiss() for conditional cancel [OK]

Hint: Use getText().contains() before dismiss() or accept() [OK]

Common Mistakes:

• Using == instead of contains() for string check
• Calling dismiss() before checking alert text
• Calling accept() and dismiss() both without condition