Prompt alert text entry in Selenium Java - Build an Automation Script

Enter text into a prompt alert and verify the result

Preconditions (1)

Step 1: Click the button that triggers the prompt alert

Step 2: Wait for the prompt alert to appear

Step 3: Enter the text 'HelloTest' into the prompt alert input field

Step 4: Accept the prompt alert

Step 5: Verify that the page displays the entered text 'HelloTest' in the result area

✅ Expected Result: The page shows the text 'HelloTest' confirming the prompt alert input was accepted

Automation Requirements - Selenium WebDriver with Java

Assertions Needed:

Verify the prompt alert is displayed before entering text

Verify the entered text appears correctly on the page after accepting the alert

Best Practices:

Use explicit waits to wait for alert presence

Use Alert interface methods to interact with prompt alerts

Use meaningful locators like By.id or By.cssSelector for page elements

Use assertions from a testing framework like TestNG or JUnit

Automated Solution

Selenium Java

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.Alert;
import org.openqa.selenium.support.ui.ExpectedConditions;
import org.openqa.selenium.support.ui.WebDriverWait;
import org.openqa.selenium.chrome.ChromeDriver;
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 PromptAlertTest {
    WebDriver driver;
    WebDriverWait wait;

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

    @Test
    public void testPromptAlertTextEntry() {
        // Click the button that triggers the prompt alert
        WebElement promptButton = driver.findElement(By.id("promptButton"));
        promptButton.click();

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

        // Verify alert is displayed
        Assert.assertNotNull(promptAlert, "Prompt alert should be present");

        // Enter text into the prompt alert
        String inputText = "HelloTest";
        promptAlert.sendKeys(inputText);

        // Accept the alert
        promptAlert.accept();

        // Verify the entered text appears on the page
        WebElement resultText = wait.until(ExpectedConditions.visibilityOfElementLocated(By.id("result")));
        Assert.assertEquals(resultText.getText(), inputText, "The result text should match the entered prompt text");
    }

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

This test script uses Selenium WebDriver with Java and TestNG for assertions.

First, it opens the target page in the setUp method.

The test clicks the button with id promptButton to open the prompt alert.

It waits explicitly for the alert to appear using WebDriverWait and ExpectedConditions.alertIsPresent().

Once the alert is present, it sends the text HelloTest to the prompt input field and accepts the alert.

Finally, it waits for the result element with id result to be visible and asserts that its text matches the entered input.

The tearDown method closes the browser after the test.

This approach ensures the test waits properly for elements and alerts, uses clear locators, and verifies the expected behavior.

Common Mistakes - 4 Pitfalls

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

{'mistake': 'Trying to find the prompt input field as a normal web element', 'why_bad': 'Prompt alert input is part of the browser alert, not the page DOM, so it cannot be located by normal selectors.', 'correct_approach': "Use the Alert interface's sendKeys() method to enter text into the prompt alert."}

Not verifying the alert is present before interacting

Using brittle locators like absolute XPath for buttons or result text

Bonus Challenge

Now add data-driven testing with 3 different input texts for the prompt alert

Show Hint

Practice

1. What is the main purpose of a prompt alert in Selenium testing?

easy

A. To allow the user to enter text in a popup window

B. To display a message without user input

C. To confirm an action with OK or Cancel buttons only

D. To automatically close the browser window

Solution

1. Step 1: Understand what a prompt alert is

   A prompt alert is a popup that asks the user to enter some text.

2. Step 2: Compare with other alert types

   Unlike simple alerts or confirmation alerts, prompt alerts allow text input.

3. Final Answer:

   To allow the user to enter text in a popup window -> Option A

4. Quick Check:

   Prompt alert = text input popup [OK]

Hint: Prompt alerts let users type text in popups [OK]

Common Mistakes:

• Confusing prompt alerts with simple alerts
• Thinking prompt alerts only show messages
• Assuming prompt alerts cannot accept input

2. Which Selenium Java method is used to enter text into a prompt alert?

easy

A. alert.sendKeys("text")

B. alert.enterText("text")

C. alert.type("text")

D. alert.setText("text")

Solution

1. Step 1: Recall Selenium Alert interface methods

   The Alert interface provides sendKeys() to input text into prompt alerts.

2. Step 2: Verify method names

   Only sendKeys() is the correct method; others do not exist in Selenium Alert API.

3. Final Answer:

   alert.sendKeys("text") -> Option A

4. Quick Check:

   Use sendKeys() to input text [OK]

Hint: Use sendKeys() to type text in prompt alerts [OK]

Common Mistakes:

• Using non-existent methods like enterText()
• Trying to use setText() which is not in Alert API
• Confusing sendKeys() with WebElement methods

3. What will happen if you run this Selenium Java code snippet?

Alert alert = driver.switchTo().alert();
alert.sendKeys("hello");
alert.accept();

medium

A. A NoAlertPresentException will be thrown

B. The prompt alert will receive 'hello' and then close by accepting

C. The alert will close without entering text

D. The alert will dismiss without accepting

Solution

1. Step 1: Analyze alert switching and text entry

   The code switches to the alert, sends text 'hello' to the prompt alert.

2. Step 2: Understand alert acceptance

   Calling accept() closes the alert by clicking OK, confirming the input.

3. Final Answer:

   The prompt alert will receive 'hello' and then close by accepting -> Option B

4. Quick Check:

   sendKeys + accept = input text and confirm [OK]

Hint: sendKeys + accept inputs text and confirms prompt [OK]

Common Mistakes:

• Assuming alert closes without text input
• Expecting dismiss() to be called instead of accept()
• Not switching to alert before sendKeys()

4. Identify the error in this Selenium Java code for entering text in a prompt alert:

Alert alert = driver.switchTo().alert();
alert.sendKeys("test");
alert.dismiss();

medium

A. alert variable should be WebElement

B. Missing driver initialization

C. sendKeys() cannot be used on alerts

D. Using dismiss() instead of accept() after sendKeys()

Solution

1. Step 1: Check alert method usage

   sendKeys() inputs text, but dismiss() cancels the prompt, ignoring input.

2. Step 2: Correct method to confirm input

   accept() should be used to confirm and submit the entered text.

3. Final Answer:

   Using dismiss() instead of accept() after sendKeys() -> Option D

4. Quick Check:

   Use accept() to confirm prompt input [OK]

Hint: Use accept() after sendKeys(), not dismiss() [OK]

Common Mistakes:

• Calling dismiss() cancels input silently
• Confusing alert with WebElement
• Forgetting to switch to alert before sendKeys()

5. You want to test a prompt alert that asks for a username. Which Selenium Java code snippet correctly enters "user123" and confirms the alert?

hard

A. driver.switchTo().alert().sendKeys("user123"); driver.switchTo().alert().accept();

B. Alert alert = driver.switchTo().alert(); alert.dismiss(); alert.sendKeys("user123");

C. Alert alert = driver.switchTo().alert(); alert.sendKeys("user123"); alert.accept();

D. driver.switchTo().alert().accept(); driver.switchTo().alert().sendKeys("user123");

Solution

1. Step 1: Understand alert handling best practice

   Store the alert in a variable to reuse it for sendKeys() and accept().

2. Step 2: Check order of operations

   First sendKeys() to enter text, then accept() to confirm and close alert.

3. Final Answer:

   Alert alert = driver.switchTo().alert(); alert.sendKeys("user123"); alert.accept(); -> Option C

4. Quick Check:

   Store alert, sendKeys, then accept [OK]

Hint: Assign alert to variable before sendKeys and accept [OK]

Common Mistakes:

• Calling accept() before sendKeys()
• Using dismiss() which cancels input
• Calling switchTo().alert() twice unnecessarily