Why advanced skills handle complex scenarios in Selenium Java - Test Execution Impact

Test Overview

This test automates a login process on a web page with dynamic elements. It verifies that advanced Selenium skills like explicit waits and exception handling help manage complex scenarios where elements load unpredictably.

Test Code - JUnit with Selenium WebDriver

Selenium Java

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.openqa.selenium.NoSuchElementException;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;

public class AdvancedLoginTest {
    WebDriver driver;
    WebDriverWait wait;

    @BeforeEach
    public void setUp() {
        driver = new ChromeDriver();
        wait = new WebDriverWait(driver, java.time.Duration.ofSeconds(10));
    }

    @Test
    public void testLoginWithDynamicElements() {
        driver.get("https://example.com/login");

        // Wait for username field to be visible
        WebElement username = wait.until(ExpectedConditions.visibilityOfElementLocated(By.id("username")));
        username.sendKeys("testuser");

        // Wait for password field to be visible
        WebElement password = wait.until(ExpectedConditions.visibilityOfElementLocated(By.id("password")));
        password.sendKeys("password123");

        // Wait for login button to be clickable
        WebElement loginButton = wait.until(ExpectedConditions.elementToBeClickable(By.id("loginBtn")));
        loginButton.click();

        // Wait for welcome message to appear
        WebElement welcomeMsg = wait.until(ExpectedConditions.visibilityOfElementLocated(By.id("welcomeMessage")));

        // Verify welcome message text
        assertEquals("Welcome, testuser!", welcomeMsg.getText());
    }

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

Execution Trace - 8 Steps

Step	Action	System State	Assertion	Result
1	Test starts and Chrome browser opens	Browser window is open and ready	—	PASS
2	Navigates to https://example.com/login	Login page loads with username, password fields and login button	—	PASS
3	Waits until username field is visible and enters 'testuser'	Username input field is visible and filled with 'testuser'	Username field is visible before typing	PASS
4	Waits until password field is visible and enters 'password123'	Password input field is visible and filled with 'password123'	Password field is visible before typing	PASS
5	Waits until login button is clickable and clicks it	Login button is clicked, page processes login	Login button is clickable before clicking	PASS
6	Waits until welcome message is visible	Welcome message appears on page	Welcome message is visible	PASS
7	Verifies welcome message text equals 'Welcome, testuser!'	Welcome message text matches expected	Assert welcome message text correctness	PASS
8	Test ends and browser closes	Browser window closed	—	PASS

Failure Scenario

Failing Condition: If the welcome message does not appear within 10 seconds after login click

Execution Trace Quiz - 3 Questions

What does the test wait for before entering the username?

A The username field to be visible

B The login button to be clickable

C The welcome message to appear

D The password field to be visible

Key Result

Using explicit waits and exception handling in Selenium helps tests handle dynamic page elements and timing issues, making tests reliable for complex scenarios.

Practice

1. Why are advanced Selenium skills important when testing complex web applications?

easy

A. They help handle dynamic elements and unexpected delays reliably.

B. They make tests run faster by skipping validations.

C. They allow tests to ignore errors and continue blindly.

D. They reduce the need for writing any assertions.

Solution

1. Step 1: Understand dynamic web elements

   Complex apps often have elements that load or change after some delay.

2. Step 2: Importance of handling delays and exceptions

   Advanced skills like waits and exception handling ensure tests wait for elements and handle errors gracefully.

3. Final Answer:

   They help handle dynamic elements and unexpected delays reliably. -> Option A

4. Quick Check:

   Advanced skills = handle dynamic elements [OK]

Hint: Think about handling delays and changes in web pages [OK]

Common Mistakes:

• Assuming tests should skip validations
• Ignoring errors instead of handling them
• Believing assertions are unnecessary

2. Which of the following is the correct way to wait for an element to be clickable in Selenium Java?

easy

A. new WebDriverWait(driver, 10).until(ExpectedConditions.elementToBeClickable(By.id("submit")));

B. driver.wait(10).until(ExpectedConditions.clickable(By.id("submit")));

C. WebDriverWait wait = new WebDriverWait(10); wait.until(clickable(By.id("submit")));

D. driver.findElement(By.id("submit")).waitUntilClickable(10);

Solution

1. Step 1: Recall correct WebDriverWait syntax

   WebDriverWait requires driver and timeout, then calls until with ExpectedConditions.

2. Step 2: Check each option's syntax

   new WebDriverWait(driver, 10).until(ExpectedConditions.elementToBeClickable(By.id("submit"))); matches correct syntax; others have wrong method calls or missing driver.

3. Final Answer:

   new WebDriverWait(driver, 10).until(ExpectedConditions.elementToBeClickable(By.id("submit"))); -> Option A

4. Quick Check:

   Correct WebDriverWait syntax = new WebDriverWait(driver, 10).until(ExpectedConditions.elementToBeClickable(By.id("submit"))); [OK]

Hint: Remember WebDriverWait needs driver and ExpectedConditions [OK]

Common Mistakes:

• Using driver.wait() which does not exist
• Missing driver parameter in WebDriverWait constructor
• Incorrect method names like waitUntilClickable

3. What will be the output of the following Selenium Java code snippet?

WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(5));
WebElement button = wait.until(ExpectedConditions.visibilityOfElementLocated(By.id("login")));
System.out.println(button.isDisplayed());

medium

A. false if element is not visible, else true

B. Always prints true regardless of element visibility

C. true if element with id 'login' is visible within 5 seconds, else TimeoutException

D. Compilation error due to wrong WebDriverWait usage

Solution

1. Step 1: Understand WebDriverWait with ExpectedConditions

   wait.until waits up to 5 seconds for element visibility or throws TimeoutException if not found.

2. Step 2: Analyze System.out.println output

   If element is visible, isDisplayed() returns true; if not found in time, exception occurs before print.

3. Final Answer:

   true if element with id 'login' is visible within 5 seconds, else TimeoutException -> Option C

4. Quick Check:

   Wait returns element or throws exception [OK]

Hint: Wait returns element or throws exception, no false return [OK]

Common Mistakes:

• Thinking wait returns false instead of exception
• Assuming isDisplayed() runs if element not found
• Confusing compilation errors with runtime exceptions

4. Identify the error in this Selenium Java code snippet that tries to click a button:

driver.findElement(By.id("submitBtn")).click();
Thread.sleep(5000);

medium

A. Missing import for By class causes compilation error.

B. Using Thread.sleep causes unnecessary fixed wait; better to use explicit wait.

C. click() method is not valid for WebElement.

D. findElement should be replaced with findElements for clicking.

Solution

1. Step 1: Analyze use of Thread.sleep

   Thread.sleep pauses test for fixed time, which is inefficient and unreliable for dynamic waits.

2. Step 2: Suggest better approach

   Explicit waits like WebDriverWait wait for conditions dynamically, improving test stability.

3. Final Answer:

   Using Thread.sleep causes unnecessary fixed wait; better to use explicit wait. -> Option B

4. Quick Check:

   Use explicit waits, not Thread.sleep [OK]

Hint: Avoid Thread.sleep; prefer explicit waits for stability [OK]

Common Mistakes:

• Thinking Thread.sleep is best for waiting
• Confusing findElement and findElements usage
• Believing click() is invalid method

5. You need to write a Selenium Java test that waits for a list of dynamic elements to appear, clicks each visible one, and logs failures without stopping the test. Which advanced skills should you combine?

hard

A. Use JavaScriptExecutor to click elements without waits or error handling.

B. Use Thread.sleep for fixed waits, no exception handling, and hard assertions to stop on failure.

C. Use implicit waits only, no exception handling, and no assertions.

D. Use explicit waits for visibility, try-catch blocks for exceptions, and soft assertions for logging failures.

Solution

1. Step 1: Handle dynamic elements with explicit waits

   Explicit waits ensure each element is visible before interacting, avoiding errors.

2. Step 2: Use try-catch to handle exceptions without stopping test

   Try-catch blocks catch errors per element, allowing test to continue and log issues.

3. Step 3: Apply soft assertions to log failures without halting

   Soft assertions record failures but let the test finish, improving test reporting.

4. Final Answer:

   Use explicit waits for visibility, try-catch blocks for exceptions, and soft assertions for logging failures. -> Option D

5. Quick Check:

   Combine waits, exception handling, soft assertions [OK]

Hint: Combine waits, try-catch, and soft assertions for robust tests [OK]

Common Mistakes:

• Using fixed waits causing flaky tests
• Not handling exceptions causing test stops
• Using hard assertions stopping tests early