Why reliable element location ensures stability in Selenium Java - Automation Benefits in Action

Verify login button is clickable using reliable locator

Preconditions (1)

Step 1: Locate the login button using a reliable locator (e.g., By.id 'loginBtn')

Step 2: Click the login button

Step 3: Verify that the next page URL contains '/dashboard'

✅ Expected Result: The login button is found and clicked successfully, and the user is navigated to the dashboard page

Automation Requirements - Selenium WebDriver with Java and JUnit 5

Assertions Needed:

Assert that the login button is displayed and enabled before clicking

Assert that the URL after clicking contains '/dashboard'

Best Practices:

Use By.id or By.name locators instead of brittle XPath or CSS selectors

Use explicit waits to wait for elements to be clickable

Use Page Object Model to separate locators and actions

Avoid hardcoded waits like Thread.sleep

Automated Solution

Selenium Java

import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
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 java.time.Duration;

import static org.junit.jupiter.api.Assertions.*;

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

    @BeforeEach
    public void setUp() {
        driver = new ChromeDriver();
        wait = new WebDriverWait(driver, Duration.ofSeconds(10));
        driver.get("https://example.com/login");
    }

    @Test
    public void testLoginButtonClickable() {
        // Locate login button by reliable locator (id)
        By loginButtonLocator = By.id("loginBtn");

        // Wait until login button is visible and clickable
        WebElement loginButton = wait.until(ExpectedConditions.elementToBeClickable(loginButtonLocator));

        // Assert button is displayed and enabled
        assertTrue(loginButton.isDisplayed(), "Login button should be visible");
        assertTrue(loginButton.isEnabled(), "Login button should be enabled");

        // Click the login button
        loginButton.click();

        // Wait until URL contains '/dashboard'
        boolean urlContainsDashboard = wait.until(ExpectedConditions.urlContains("/dashboard"));

        // Assert navigation to dashboard
        assertTrue(urlContainsDashboard, "URL should contain '/dashboard' after login");
    }

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

This test uses Selenium WebDriver with Java and JUnit 5 to automate the manual test case.

Setup: We open the Chrome browser and navigate to the login page URL.

Locating element: We use By.id("loginBtn") which is a reliable locator because IDs are unique and less likely to change.

Waiting: We use explicit wait ExpectedConditions.elementToBeClickable to wait until the login button is ready to be clicked. This avoids flaky tests caused by timing issues.

Assertions: We check the button is visible and enabled before clicking. After clicking, we wait and assert that the URL contains '/dashboard' to confirm navigation.

Teardown: We close the browser after the test to clean up.

This approach ensures stability because it uses reliable locators, explicit waits, and clear assertions, reducing failures caused by page load delays or locator changes.

Common Mistakes - 4 Pitfalls

Using XPath with absolute paths like /html/body/div[2]/button

Using Thread.sleep() to wait for elements

Not checking if element is visible or enabled before clicking

Hardcoding URLs or text without verification

Bonus Challenge

Now add data-driven testing with 3 different login button IDs to verify stability across variations.

Show Hint

Practice

1. Why is it important to use reliable locators like id or name in Selenium tests?

easy

A. Because they are harder to write

B. Because they make the test run slower

C. Because they help tests run without unexpected failures

D. Because they always change on every page load

Solution

1. Step 1: Understand locator stability

   Reliable locators like id or name rarely change, so tests find elements easily.

2. Step 2: Link stability to test success

   Stable locators prevent test failures caused by missing elements, making tests reliable.

3. Final Answer:

   Because they help tests run without unexpected failures -> Option C

4. Quick Check:

   Stable locators = fewer test failures [OK]

Hint: Pick locators that rarely change to avoid test breaks [OK]

Common Mistakes:

• Choosing locators that change often
• Using complex XPath unnecessarily
• Ignoring locator uniqueness

2. Which of the following is the correct way to locate an element by its id in Selenium Java?

easy

A. driver.findElement(By.cssSelector("username"))

B. driver.findElement(By.name="username");

C. driver.findElement(By.xpath="//input[@id='username']");

D. driver.findElement(By.id("username"));

Solution

1. Step 1: Check correct method syntax

   The correct method to locate by id is By.id("value") with parentheses and quotes.

2. Step 2: Verify option correctness

   driver.findElement(By.id("username")); uses correct syntax: driver.findElement(By.id("username")); others have syntax errors or wrong usage.

3. Final Answer:

   driver.findElement(By.id("username")); -> Option D

4. Quick Check:

   Use By.id("idValue") with parentheses [OK]

Hint: Remember: By.id("value") uses parentheses and quotes [OK]

Common Mistakes:

• Using assignment (=) instead of method call
• Missing parentheses in By.id
• Confusing By.name and By.id

3. Given the code snippet:

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

What happens if the element with id='submitBtn' is not present on the page?

medium

A. The test passes without clicking

B. A NoSuchElementException is thrown and test fails

C. The button variable is null and test continues

D. The test waits forever for the element

Solution

1. Step 1: Understand findElement behavior

   When findElement cannot find the element, it throws NoSuchElementException.

2. Step 2: Effect on test execution

   This exception causes the test to fail immediately unless caught, so the test does not pass or continue silently.

3. Final Answer:

   A NoSuchElementException is thrown and test fails -> Option B

4. Quick Check:

   Missing element = NoSuchElementException [OK]

Hint: Missing element causes NoSuchElementException failure [OK]

Common Mistakes:

• Assuming test passes if element missing
• Thinking findElement returns null
• Believing test waits forever without timeout

4. You wrote this code:

WebElement element = driver.findElement(By.xpath("//div[@class='btn']"));
element.click();

But the test fails intermittently. What is the most likely cause?

medium

A. The XPath locator is unstable and matches multiple elements

B. The element is always visible and clickable

C. The driver is not initialized

D. The click() method is misspelled

Solution

1. Step 1: Analyze locator reliability

   An XPath like //div[@class='btn'] may match multiple elements or change if classes change, causing instability.

2. Step 2: Link instability to intermittent failure

   Unstable locators cause tests to fail sometimes when the wrong element is found or none is found.

3. Final Answer:

   The XPath locator is unstable and matches multiple elements -> Option A

4. Quick Check:

   Unstable XPath = flaky test failures [OK]

Hint: Check if locator matches multiple or changing elements [OK]

Common Mistakes:

• Ignoring locator uniqueness
• Assuming driver not initialized without checking
• Overlooking typos in method names

5. You want to improve test stability by choosing the best locator for a login button. The button has:

• id="loginBtn"
• class="btn primary"
• text="Login"

Which locator is the most reliable and why?

hard

A. By.id("loginBtn") because id is unique and stable

B. By.className("btn") because class is easy to use

C. By.xpath("//button[text()='Login']") because text is visible

D. By.cssSelector(".primary") because it matches style

Solution

1. Step 1: Evaluate locator uniqueness and stability

   The id attribute is unique per page and less likely to change, making it the most stable locator.

2. Step 2: Compare other locators

   Class names and text can change or match multiple elements, so they are less reliable.

3. Final Answer:

   By.id("loginBtn") because id is unique and stable -> Option A

4. Quick Check:

   Unique id locator = best stability [OK]

Hint: Pick unique id over class or text for stable locators [OK]

Common Mistakes:

• Using class which may not be unique
• Using text which can change or be duplicated
• Choosing CSS selectors by style which may vary