Page title and URL retrieval in Selenium Java - Deep Dive

Overview - Page title and URL retrieval

What is it?

Page title and URL retrieval means getting the current web page's title and its web address (URL) using automated tests. In Selenium with Java, this helps verify that the browser is showing the right page during testing. The title is the text shown on the browser tab, and the URL is the exact address in the browser's address bar. These are basic but important checks in web testing.

Why it matters

Without checking the page title and URL, tests might miss if the browser navigated to the wrong page or if the page loaded incorrectly. This can cause bugs to go unnoticed, leading to bad user experiences or broken features. Retrieving and verifying these values ensures the website behaves as expected and helps catch navigation errors early.

Where it fits

Before learning this, you should know how to set up Selenium WebDriver and open a web page. After this, you can learn more about interacting with page elements, waiting for page loads, and validating page content. This topic is a foundation for verifying navigation and page correctness in automated tests.

Mental Model

Core Idea

Retrieving the page title and URL is like reading the label and address on a package to confirm it’s the right one before opening it.

Think of it like...

Imagine you order a book online. When the delivery arrives, you check the label (page title) and the address (URL) on the package to make sure it’s the book you ordered and it came to your house. Similarly, in testing, you check the page title and URL to confirm the browser shows the correct page.

┌─────────────────────────────┐
│        Browser Window       │
│ ┌───────────────────────┐ │
│ │ Page Title (Tab Text) │ │
│ └───────────────────────┘ │
│ ┌───────────────────────┐ │
│ │ URL (Address Bar)     │ │
│ └───────────────────────┘ │
│ ┌───────────────────────┐ │
│ │ Web Page Content      │ │
│ └───────────────────────┘ │
└─────────────────────────────┘

Build-Up - 7 Steps

1

Foundation

Understanding Page Title and URL

Concept: Learn what page title and URL mean in a web browser context.

The page title is the text shown on the browser tab. It usually describes the page content. The URL is the web address shown in the browser's address bar. Both help identify the page you are viewing.

Result

You can recognize the page title and URL visually in any browser.

Knowing what the page title and URL represent helps you understand why verifying them matters in testing.

2

Foundation

Setting Up Selenium WebDriver

Concept: Prepare the Selenium WebDriver to open a browser and load a web page.

Install Selenium Java bindings and a browser driver (like ChromeDriver). Write code to create a WebDriver instance and open a URL using driver.get("https://example.com").

Result

A browser window opens and loads the specified web page.

Setting up WebDriver is essential before you can retrieve page title or URL.

3

Intermediate

Retrieving Page Title in Selenium Java

🤔Before reading on: do you think driver.getTitle() returns the page title as a String or an object? Commit to your answer.

Concept: Use the getTitle() method of WebDriver to get the current page title as a String.

Example: String title = driver.getTitle(); System.out.println("Page title is: " + title);

Result

The console prints the exact title text of the current page.

Understanding that getTitle() returns a simple String lets you easily compare it with expected titles in tests.

4

Intermediate

Retrieving Current URL in Selenium Java

🤔Before reading on: do you think driver.getCurrentUrl() returns the URL before or after any redirects? Commit to your answer.

Concept: Use the getCurrentUrl() method of WebDriver to get the current page URL as a String after all navigation and redirects.

Example: String url = driver.getCurrentUrl(); System.out.println("Current URL is: " + url);

Result

The console prints the full URL of the page currently loaded in the browser.

Knowing getCurrentUrl() reflects the final URL after redirects helps you verify navigation correctness.

5

Intermediate

Using Assertions to Verify Title and URL

🤔Before reading on: do you think assertions stop the test immediately on failure or continue running? Commit to your answer.

Concept: Use assertions to check if the retrieved title and URL match expected values, causing test failure if they don't.

Example with JUnit: import static org.junit.jupiter.api.Assertions.*; String expectedTitle = "Example Domain"; assertEquals(expectedTitle, driver.getTitle()); String expectedUrl = "https://example.com/"; assertEquals(expectedUrl, driver.getCurrentUrl());

Result

Test passes if title and URL match; fails with error if not.

Assertions provide automated checks that confirm the page is correct, preventing silent errors.

6

Advanced

Handling Dynamic Titles and URLs

🤔Before reading on: do you think exact string matching always works for titles and URLs on dynamic sites? Commit to your answer.

Concept: Learn strategies to handle pages where titles or URLs change dynamically, like using contains() or regex matching.

Example: String title = driver.getTitle(); assertTrue(title.contains("Welcome")); String url = driver.getCurrentUrl(); assertTrue(url.matches("https://example.com/page/\d+"));

Result

Tests pass if title or URL partially match expected patterns, allowing flexibility.

Knowing how to handle dynamic values prevents flaky tests that fail due to small expected changes.

7

Expert

Avoiding Common Pitfalls in Title and URL Checks

🤔Before reading on: do you think checking title and URL alone guarantees the page loaded fully and correctly? Commit to your answer.

Concept: Understand the limitations of title and URL checks and learn to combine them with other validations like element presence or page state.

Example: // Title and URL check assertEquals("Home", driver.getTitle()); assertEquals("https://example.com/home", driver.getCurrentUrl()); // Additional check assertTrue(driver.findElement(By.id("main-content")).isDisplayed());

Result

Tests become more reliable by verifying page content along with title and URL.

Knowing that title and URL are necessary but not sufficient checks helps build robust tests.

Under the Hood

When Selenium WebDriver calls getTitle() or getCurrentUrl(), it communicates with the browser through the WebDriver protocol. The browser returns the current page's title or URL from its internal state. These values reflect the page loaded in the active tab, updated after navigation or redirects. The driver does not parse the page itself but relies on the browser's rendering engine to provide accurate information.

Why designed this way?

This design separates test code from browser internals, allowing WebDriver to work with many browsers uniformly. Returning simple strings for title and URL keeps the API easy to use and efficient. Alternatives like parsing page source would be slower and more complex. The WebDriver protocol standardizes these commands for cross-browser compatibility.

┌───────────────┐       ┌───────────────┐       ┌───────────────┐
│ Selenium Test │──────▶│ WebDriver API │──────▶│   Browser     │
│   (Java)      │       │ (Commands)    │       │ (Rendering)   │
└───────────────┘       └───────────────┘       └───────────────┘
        │                      │                      │
        │ getTitle()           │                      │
        │--------------------▶│                      │
        │                      │ get title string     │
        │                      │--------------------▶│
        │                      │                      │
        │                      │◀--------------------│
        │◀---------------------│                      │
        │  returns title string │                      │

Myth Busters - 4 Common Misconceptions

Quick: Does driver.getTitle() always return the page title immediately after driver.get()? Commit yes or no.

Common Belief: driver.getTitle() instantly returns the correct page title right after calling driver.get(url).

Reality: If the page is still loading or redirecting, getTitle() may return an old or empty title. You often need to wait for the page to load fully before retrieving the title.

Why it matters: Without waiting, tests may fail or pass incorrectly, causing flaky or unreliable results.

Quick: Does driver.getCurrentUrl() return the URL you initially requested or the final URL after redirects? Commit your answer.

Common Belief: driver.getCurrentUrl() always returns the URL passed to driver.get(), ignoring redirects.

Reality: driver.getCurrentUrl() returns the actual URL loaded in the browser after all redirects and navigation.

Why it matters: Tests that expect the original URL may fail if redirects occur, leading to false negatives.

Quick: Is checking only the page title enough to confirm the page loaded correctly? Commit yes or no.

Common Belief: If the page title is correct, the page has loaded fully and correctly.

Reality: The title can be correct even if page content is missing or broken. Additional checks are needed for full validation.

Why it matters: Relying solely on title can miss critical page errors, causing bugs to slip through.

Quick: Does getTitle() return the visible text on the page or the title tag content? Commit your answer.

Common Belief: getTitle() returns any visible text on the page.

Reality: getTitle() returns only the content of the