Multi-page navigation flow in Selenium Java - Build an Automation Script

Verify multi-page navigation from Home to Profile page

Preconditions (3)

Step 1: Navigate to the Home page URL

Step 2: Click on the 'Login' button identified by id 'loginBtn'

Step 3: On the Login page, enter '[e-mail]' in the email field with id 'emailInput'

Step 4: Enter 'TestPass123' in the password field with id 'passwordInput'

Step 5: Click the 'Submit' button with id 'submitLogin'

Step 6: Wait for the Dashboard page to load and verify URL contains '/dashboard'

Step 7: Click on the 'Profile' link with id 'profileLink'

Step 8: Wait for the Profile page to load and verify URL contains '/profile'

✅ Expected Result: User successfully logs in, navigates to Dashboard, then navigates to Profile page with correct URLs and page elements loaded

Automation Requirements - Selenium WebDriver with Java and TestNG

Assertions Needed:

Verify current URL contains '/dashboard' after login

Verify current URL contains '/profile' after clicking Profile link

Best Practices:

Use explicit waits to wait for elements and page loads

Use By.id locators for element identification

Use TestNG assertions for validation

Organize code with setup and teardown methods

Close browser after test execution

Automated Solution

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

import java.time.Duration;

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

    @BeforeClass
    public void setUp() {
        // Assuming chromedriver is in system PATH
        driver = new ChromeDriver();
        wait = new WebDriverWait(driver, Duration.ofSeconds(10));
        driver.manage().window().maximize();
    }

    @Test
    public void testMultiPageNavigationFlow() {
        // Step 1: Navigate to Home page
        driver.get("https://example.com/home");

        // Step 2: Click Login button
        WebElement loginBtn = wait.until(ExpectedConditions.elementToBeClickable(By.id("loginBtn")));
        loginBtn.click();

        // Step 3: Enter email
        WebElement emailInput = wait.until(ExpectedConditions.visibilityOfElementLocated(By.id("emailInput")));
        emailInput.sendKeys("[e-mail]");

        // Step 4: Enter password
        WebElement passwordInput = driver.findElement(By.id("passwordInput"));
        passwordInput.sendKeys("TestPass123");

        // Step 5: Click Submit button
        WebElement submitLogin = driver.findElement(By.id("submitLogin"));
        submitLogin.click();

        // Step 6: Wait for Dashboard page and verify URL
        wait.until(ExpectedConditions.urlContains("/dashboard"));
        String currentUrl = driver.getCurrentUrl();
        Assert.assertTrue(currentUrl.contains("/dashboard"), "URL should contain '/dashboard' after login");

        // Step 7: Click Profile link
        WebElement profileLink = wait.until(ExpectedConditions.elementToBeClickable(By.id("profileLink")));
        profileLink.click();

        // Step 8: Wait for Profile page and verify URL
        wait.until(ExpectedConditions.urlContains("/profile"));
        currentUrl = driver.getCurrentUrl();
        Assert.assertTrue(currentUrl.contains("/profile"), "URL should contain '/profile' after clicking profile link");
    }

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

This test uses Selenium WebDriver with Java and TestNG to automate the multi-page navigation flow.

Setup: The @BeforeClass method initializes the ChromeDriver and WebDriverWait with a 10-second timeout. The browser window is maximized for better visibility.

Test Steps: The test method testMultiPageNavigationFlow follows the manual test steps exactly:

• Navigate to the Home page URL.
• Click the Login button using an explicit wait to ensure it is clickable.
• Wait for the email input to be visible, then enter the email.
• Enter the password.
• Click the Submit button.
• Wait until the URL contains '/dashboard' to confirm login success, then assert this condition.
• Click the Profile link after waiting for it to be clickable.
• Wait until the URL contains '/profile' and assert this condition.

Teardown: The @AfterClass method closes the browser to clean up after the test.

This structure uses explicit waits to avoid timing issues and uses TestNG assertions to verify navigation success. Locators use By.id for reliability and clarity.

Common Mistakes - 4 Pitfalls

Using Thread.sleep() instead of explicit waits

Using brittle XPath locators instead of stable IDs

Not verifying the URL after navigation

Not closing the browser after test

Bonus Challenge

Now add data-driven testing with 3 different user credentials to verify login and navigation for each user.

Show Hint

Practice

1. What is the main purpose of multi-page navigation testing in Selenium?

easy

A. To check database connections

B. To verify users can move through pages correctly

C. To test API responses

D. To validate CSS styles on a page

Solution

1. Step 1: Understand multi-page navigation testing

   It focuses on checking if users can move from one page to another as expected.

2. Step 2: Identify the correct purpose

   Among the options, only verifying page navigation matches this goal.

3. Final Answer:

   To verify users can move through pages correctly -> Option B

4. Quick Check:

   Multi-page navigation = verify page moves [OK]

Hint: Focus on user movement between pages [OK]

Common Mistakes:

• Confusing navigation testing with API or database testing
• Thinking CSS validation is part of navigation
• Ignoring the user flow aspect

2. Which Selenium Java command is used to navigate to a new URL in a multi-page test?

easy

A. driver.get("https://example.com")

B. driver.click("https://example.com")

C. driver.navigateTo("https://example.com")

D. driver.openPage("https://example.com")

Solution

1. Step 1: Recall Selenium command to open URL

   The correct method is driver.get(url) to load a page.

2. Step 2: Check options for correct syntax

   Only driver.get("https://example.com") is valid Selenium Java syntax.

3. Final Answer:

   driver.get("https://example.com") -> Option A

4. Quick Check:

   Open URL = driver.get() [OK]

Hint: Use driver.get() to open URLs [OK]

Common Mistakes:

• Using non-existent methods like navigateTo or openPage
• Trying to click URLs directly
• Confusing navigation commands with click actions

3. Given the code snippet:

driver.get("https://example.com/page1");
driver.findElement(By.id("nextBtn")).click();
String currentUrl = driver.getCurrentUrl();

What will currentUrl contain after execution if clicking the button navigates to page2?

medium

A. "https://example.com/page1"

B. null

C. Throws NoSuchElementException

D. "https://example.com/page2"

Solution

1. Step 1: Understand navigation flow in code

   The driver opens page1, then clicks a button that navigates to page2.

2. Step 2: Check what getCurrentUrl() returns after navigation

   It returns the URL of the current page, which should be page2 after clicking.

3. Final Answer:

   "https://example.com/page2" -> Option D

4. Quick Check:

   After click, URL updates to new page [OK]

Hint: getCurrentUrl() shows current page URL [OK]

Common Mistakes:

• Assuming URL stays the same after navigation
• Confusing getCurrentUrl() with getPageSource()
• Thinking click throws exception without checking element presence

4. Identify the error in this Selenium Java code for multi-page navigation:

driver.get("https://example.com/home");
WebElement link = driver.findElement(By.className("nav-link"));
link.click();
String title = driver.getTitle();
assert title.equals("Home Page");

medium

A. Missing driver.quit() after test

B. Incorrect assertion method syntax

C. Using className locator without checking multiple matches

D. Using getTitle() instead of getCurrentUrl()

Solution

1. Step 1: Analyze locator usage

   Using By.className("nav-link") may find multiple elements, causing ambiguity.

2. Step 2: Check other code parts

   Assertion syntax is correct, driver.quit() is optional, and getTitle() is valid for title check.

3. Final Answer:

   Using className locator without checking multiple matches -> Option C

4. Quick Check:

   className may match many elements [OK]

Hint: Ensure locators uniquely identify elements [OK]

Common Mistakes:

• Ignoring that className can match multiple elements
• Thinking getTitle() is wrong for title checks
• Believing driver.quit() is mandatory in every snippet

5. You want to test a multi-page flow where after login, the user clicks a menu to open a settings page, then clicks a logout button. Which Selenium Java approach correctly verifies the flow?

hard

A. Use driver.get() for login page, findElement().sendKeys() for login, click menu link, verify settings URL, click logout, verify login URL

B. Use driver.navigate().refresh() after each click to ensure page loads

C. Use driver.get() only once at login, then use JavaScript to change URLs for other pages

D. Use driver.findElement(By.tagName("button")).click() for all clicks without verifying page changes

Solution

1. Step 1: Outline correct multi-page test steps

   Start at login page, perform login, navigate via clicks, verify URLs after each step.

2. Step 2: Evaluate options for best practice

   Use driver.get() for login page, findElement().sendKeys() for login, click menu link, verify settings URL, click logout, verify login URL follows proper navigation and verification. Others misuse refresh, JavaScript URL changes, or skip verification.

3. Final Answer:

   Use driver.get() for login page, findElement().sendKeys() for login, click menu link, verify settings URL, click logout, verify login URL -> Option A

4. Quick Check:

   Navigate and verify URLs step-by-step [OK]

Hint: Navigate and verify each page URL after clicks [OK]

Common Mistakes:

• Refreshing unnecessarily after clicks
• Changing URLs via JavaScript instead of real navigation
• Clicking without verifying page changes