What is a locator?

Understand how Selenium finds elements on a web page.

What You'll Learn

• What a locator is and how Selenium uses it to find elements.
• The relationship between HTML elements, the DOM, and locators.
• Why good locators are critical for stable, maintainable tests.
• Basic types of locators you'll meet later (id, name, etc.)—at a concept level only.

Why This Lab Matters

Before Selenium can click a button, type into a field, or read some text, it must first find the right element on the page.

The only way it can do that is through locators. If your locators are weak or unstable:

• Tests will break when the UI changes slightly.
• You may interact with the wrong element.
• Debugging becomes painful and slow.

Understanding locators from day one gives you a strong foundation for every future Selenium test you write.

Prerequisites

• Very basic idea of what a web page is (HTML elements like buttons, links, inputs, etc.).
• High-level awareness of Selenium WebDriver (you've at least heard of WebDriver and findElement(...)).
• No coding required in this lab. This is a concept-only introduction.

Core Concepts

Step 1 – See the Page Like Selenium Does

1. Open any website you use often (e.g., a login page or a simple form).
2. Remember: Selenium does not see colors, positions, or fonts.
3. It only sees the DOM tree: a structure of elements, attributes, and text.

Step 2 – Connect Elements to Their "Address"

1. Pick a button or input field on the page.
2. Conceptually, ask:
   • What makes this element different from others?
   • Does it have a unique id or name?
   • Is there a label or text that clearly identifies it?
3. Think of these attributes as potential locator building blocks.

Step 3 – Check If a Locator Is Unique and Stable

For each potential locator idea, ask:

• Uniqueness: "Does this identify only one element?"
• Stability: "Is this likely to stay the same when the UI changes slightly?"
• Clarity: "Is it clear what this locator refers to when I read it 2 months from now?"

Step 4 – Imagine What Happens When the Locator Fails

Think through two failure modes:

1. No element found
   • Test fails with a "no such element" error.
   • Often happens when the locator no longer matches anything in the DOM.
2. Wrong element found
   • Selenium clicks or types into the wrong element.
   • The test may still run… but the behavior is incorrect and harder to notice.

Step 5 – Define a Simple Locator Strategy for Yourself

Before you move to the next labs, define your personal locator strategy (you can refine it later), for example:

1. Try id first (if unique and stable).
2. If not available, try name or a clean attribute (like data-*).
3. Only then consider CSS selectors or XPath—and keep them as simple as possible.

Code Example

In this introductory lab, we intentionally do not use code.

For now, you only need to understand these ideas:

• Selenium uses methods like findElement(...) and findElements(...).
• These methods always receive a locator.
• The locator is defined through something like the By class (e.g., "find the element by id" or "by name").

You will see and write real code using these concepts in the upcoming labs, once the foundation is solid.

Pro Tips (From Real Projects)

• Start with the simplest locator that is still unique and stable.
• If the UI is under active development, expect change and design locators that tolerate minor UI tweaks.
• Ask developers (if possible) to add meaningful ids or data attributes for key elements.
• Keep locators centralized (e.g., in one place per page in your code) so a change in the UI doesn't require edits everywhere.
• Regularly review failing tests to see if the root cause is a weak locator pattern you can improve globally.

Common Mistakes to Avoid

• Treating locators as an afterthought instead of an important design decision.
• Using locators that rely only on:
  • visual position ("the second button in the row"),
  • unstable attributes (random IDs, auto-generated class names).
• Copy-pasting complex locators from browser tools without understanding them.
• Creating locators that match multiple elements and assuming Selenium will "guess the right one".
• Ignoring locator quality during early test-writing—then suffering with flaky tests later.

If you understand this lab well, you're ready to move on to practical locator strategies and start writing real locators in code in the next labs.