Finding elements reliably

from selenium.webdriver.common.by import By

LOCATORS_PAGE = "https://www.selenium.dev/selenium/web/locators_tests/locators.html"


def test_first_matching_element(driver):
    driver.get(LOCATORS_PAGE)
    first_input = driver.find_element(By.CLASS_NAME, "information")

    assert first_input.get_attribute("id") == "fname"


def test_subset_of_dom(driver):
    driver.get(LOCATORS_PAGE)
    form = driver.find_element(By.TAG_NAME, "form")
    input_element = form.find_element(By.CLASS_NAME, "information")

    assert input_element.get_attribute("id") == "fname"


def test_optimized_locator(driver):
    driver.get(LOCATORS_PAGE)
    input_element = driver.find_element(By.CSS_SELECTOR, "form .information")

    assert input_element.get_attribute("id") == "fname"


def test_all_matching_elements(driver):
    driver.get(LOCATORS_PAGE)
    inputs = driver.find_elements(By.TAG_NAME, "input")

    assert len(inputs) > 1


def test_evaluating_shadow_dom(driver):
    driver.implicitly_wait(5)
    driver.get('https://www.selenium.dev/selenium/web/shadowRootPage.html')

    shadow_host = driver.find_element(By.TAG_NAME, 'custom-checkbox-element')
    shadow_root = shadow_host.shadow_root
    assert shadow_root
    shadow_content = shadow_root.find_element(By.CSS_SELECTOR, 'input[type=checkbox]')

    assert shadow_host.is_displayed()
    assert shadow_content.is_displayed()


def test_get_element(driver):
    driver.get(LOCATORS_PAGE)

    elements = driver.find_elements(By.TAG_NAME, 'p')
    for element in elements:
        print(f"Paragraph text:{element.text}")

    assert len(elements) > 0


def test_find_elements_from_element(driver):
    driver.get(LOCATORS_PAGE)

    form = driver.find_element(By.TAG_NAME, 'form')
    elements = form.find_elements(By.TAG_NAME, 'input')
    for element in elements:
        print(element.get_attribute('value'))

    assert len(elements) > 0


def test_get_active_element(driver):
    driver.get(LOCATORS_PAGE)

    driver.find_element(By.CSS_SELECTOR, '#fname').send_keys('webElement')
    attr = driver.switch_to.active_element.get_attribute('name')

    assert attr == 'fname'

using Microsoft.VisualStudio.TestTools.UnitTesting;
using OpenQA.Selenium;

namespace SeleniumDocs.Elements
{
    [TestClass]
    public class FindersTest : BaseTest
    {
        private const string LocatorsPage = "https://www.selenium.dev/selenium/web/locators_tests/locators.html";

        [TestMethod]
        public void FindsFirstMatchingElement()
        {
            StartDriver();
            driver.Url = LocatorsPage;
            IWebElement firstInput = driver.FindElement(By.ClassName("information"));

            Assert.AreEqual("fname", firstInput.GetAttribute("id"));
        }

        [TestMethod]
        public void FindsElementWithinASubsetOfTheDom()
        {
            StartDriver();
            driver.Url = LocatorsPage;
            IWebElement form = driver.FindElement(By.TagName("form"));
            IWebElement input = form.FindElement(By.ClassName("information"));

            Assert.AreEqual("fname", input.GetAttribute("id"));
        }

        [TestMethod]
        public void UsesAnOptimizedLocator()
        {
            StartDriver();
            driver.Url = LocatorsPage;
            IWebElement input = driver.FindElement(By.CssSelector("form .information"));

            Assert.AreEqual("fname", input.GetAttribute("id"));
        }

        [TestMethod]
        public void FindsAllMatchingElements()
        {
            StartDriver();
            driver.Url = LocatorsPage;
            var inputs = driver.FindElements(By.TagName("input"));

            Assert.IsTrue(inputs.Count > 1);
        }

        [TestMethod]
        public void GetsElementFromACollection()
        {
            StartDriver();
            driver.Url = LocatorsPage;

            var elements = driver.FindElements(By.TagName("p"));
            foreach (var element in elements)
            {
                System.Console.WriteLine("Paragraph text:" + element.Text);
            }

            Assert.IsTrue(elements.Count > 0);
        }

        [TestMethod]
        public void FindsElementsFromElement()
        {
            StartDriver();
            driver.Url = LocatorsPage;

            IWebElement form = driver.FindElement(By.TagName("form"));
            var elements = form.FindElements(By.TagName("input"));
            foreach (var e in elements)
            {
                System.Console.WriteLine(e.GetAttribute("value"));
            }

            Assert.IsTrue(elements.Count > 0);
        }

        [TestMethod]
        public void GetsActiveElement()
        {
            StartDriver();
            driver.Url = LocatorsPage;

            driver.FindElement(By.CssSelector("#fname")).SendKeys("webElement");
            string attr = driver.SwitchTo().ActiveElement().GetAttribute("name");

            Assert.AreEqual("fname", attr);
        }

        [TestMethod]
        public void FindsElementInShadowDom()
        {
            StartDriver();
            driver.Url = "https://www.selenium.dev/selenium/web/shadowRootPage.html";

            IWebElement shadowHost = driver.FindElement(By.CssSelector("custom-checkbox-element"));
            ISearchContext shadowRoot = shadowHost.GetShadowRoot();
            IWebElement shadowContent = shadowRoot.FindElement(By.CssSelector("input[type=checkbox]"));

            Assert.IsTrue(shadowContent.Displayed);
        }
    }
}

# frozen_string_literal: true

require 'spec_helper'

RSpec.describe 'Element Finders' do
  let(:driver) { start_session }
  let(:locators_page) { 'https://www.selenium.dev/selenium/web/locators_tests/locators.html' }

  it 'finds the first matching element' do
    driver.navigate.to locators_page
    first_input = driver.find_element(class: 'information')

    expect(first_input.attribute('id')).to eq('fname')
  end

  it 'uses a subset of the dom to find an element' do
    driver.navigate.to locators_page
    form = driver.find_element(tag_name: 'form')
    input_element = form.find_element(class: 'information')

    expect(input_element.attribute('id')).to eq('fname')
  end

  it 'uses an optimized locator' do
    driver.navigate.to locators_page
    input_element = driver.find_element(css: 'form .information')

    expect(input_element.attribute('id')).to eq('fname')
  end

  it 'finds all matching elements' do
    driver.navigate.to locators_page
    inputs = driver.find_elements(tag_name: 'input')

    expect(inputs.size).to be > 1
  end

  # rubocop:disable RSpec/Output
  it 'gets an element from a collection' do
    driver.navigate.to locators_page
    elements = driver.find_elements(tag_name: 'p')
    elements.each { |e| puts "Paragraph text:#{e.text}" }

    expect(elements).not_to be_empty
  end

  it 'finds element from element' do
    driver.navigate.to locators_page
    form = driver.find_element(tag_name: 'form')
    elements = form.find_elements(tag_name: 'input')
    elements.each { |e| puts e.attribute('value') }

    expect(elements).not_to be_empty
  end
  # rubocop:enable RSpec/Output

  it 'finds the active element' do
    driver.navigate.to locators_page
    driver.find_element(css: '#fname').send_keys('webElement')
    attr = driver.switch_to.active_element.attribute('name')

    expect(attr).to eq('fname')
  end

  it 'finds an element in the shadow dom' do
    driver.navigate.to 'https://www.selenium.dev/selenium/web/shadowRootPage.html'

    shadow_host = driver.find_element(css: 'custom-checkbox-element')
    shadow_root = shadow_host.shadow_root
    shadow_content = shadow_root.find_element(css: 'input[type=checkbox]')

    expect(shadow_content).to be_displayed
  end
end

const {Builder, By} = require('selenium-webdriver');
const assert = require('assert');

const LOCATORS_PAGE = 'https://www.selenium.dev/selenium/web/locators_tests/locators.html';

describe('Finders', function () {
  it('finds the first matching element', async function () {
    let driver = await new Builder().forBrowser('chrome').build();
    await driver.get(LOCATORS_PAGE);
    const firstInput = await driver.findElement(By.className('information'));

    assert.equal(await firstInput.getAttribute('id'), 'fname');
    await driver.quit();
  });

  it('finds an element within a subset of the DOM', async function () {
    let driver = await new Builder().forBrowser('chrome').build();
    await driver.get(LOCATORS_PAGE);
    const form = await driver.findElement(By.tagName('form'));
    const input = await form.findElement(By.className('information'));

    assert.equal(await input.getAttribute('id'), 'fname');
    await driver.quit();
  });

  it('uses an optimized locator', async function () {
    let driver = await new Builder().forBrowser('chrome').build();
    await driver.get(LOCATORS_PAGE);
    const input = await driver.findElement(By.css('form .information'));

    assert.equal(await input.getAttribute('id'), 'fname');
    await driver.quit();
  });

  it('finds all matching elements', async function () {
    let driver = await new Builder().forBrowser('chrome').build();
    await driver.get(LOCATORS_PAGE);
    const inputs = await driver.findElements(By.tagName('input'));

    assert.ok(inputs.length > 1);
    await driver.quit();
  });

  it('gets an element from a collection', async function () {
    let driver = await new Builder().forBrowser('chrome').build();
    await driver.get(LOCATORS_PAGE);
    const elements = await driver.findElements(By.tagName('p'));
    for (const element of elements) {
      console.log('Paragraph text:' + await element.getText());
    }

    assert.ok(elements.length > 0);
    await driver.quit();
  });

  it('finds elements from an element', async function () {
    let driver = await new Builder().forBrowser('chrome').build();
    await driver.get(LOCATORS_PAGE);
    const form = await driver.findElement(By.css('form'));
    const elements = await form.findElements(By.css('input'));
    for (const e of elements) {
      console.log(await e.getAttribute('value'));
    }

    assert.ok(elements.length > 0);
    await driver.quit();
  });

  it('gets the active element', async function () {
    let driver = await new Builder().forBrowser('chrome').build();
    await driver.get(LOCATORS_PAGE);
    await driver.findElement(By.css('#fname')).sendKeys('webElement');
    const attr = await driver.switchTo().activeElement().getAttribute('name');

    assert.equal(attr, 'fname');
    await driver.quit();
  });

  it('finds an element in the shadow DOM', async function () {
    let driver = await new Builder().forBrowser('chrome').build();
    await driver.get('https://www.selenium.dev/selenium/web/shadowRootPage.html');

    const shadowHost = await driver.findElement(By.css('custom-checkbox-element'));
    const shadowRoot = await shadowHost.getShadowRoot();
    const shadowContent = await shadowRoot.findElement(By.css('input[type=checkbox]'));

    assert.ok(await shadowContent.isDisplayed());
    await driver.quit();
  });
});

package dev.selenium.elements

import dev.selenium.BaseTest
import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.Assertions.assertTrue
import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.TestInstance
import org.openqa.selenium.By
import java.time.Duration

@TestInstance(TestInstance.Lifecycle.PER_CLASS)
class FindersTest : BaseTest() {

    private val locatorsPage = "https://www.selenium.dev/selenium/web/locators_tests/locators.html"

    @Test
    fun findsFirstMatchingElement() {
        driver.get(locatorsPage)
        val firstInput = driver.findElement(By.className("information"))

        assertEquals("fname", firstInput.getAttribute("id"))
    }

    @Test
    fun findsElementWithinASubsetOfTheDom() {
        driver.get(locatorsPage)
        val form = driver.findElement(By.tagName("form"))
        val input = form.findElement(By.className("information"))

        assertEquals("fname", input.getAttribute("id"))
    }

    @Test
    fun usesAnOptimizedLocator() {
        driver.get(locatorsPage)
        val input = driver.findElement(By.cssSelector("form .information"))

        assertEquals("fname", input.getAttribute("id"))
    }

    @Test
    fun findsAllMatchingElements() {
        driver.get(locatorsPage)
        val inputs = driver.findElements(By.tagName("input"))

        assertTrue(inputs.size > 1)
    }

    @Test
    fun getsElementFromACollection() {
        driver.get(locatorsPage)
        val elements = driver.findElements(By.tagName("p"))
        for (element in elements) {
            println("Paragraph text:" + element.text)
        }

        assertTrue(elements.isNotEmpty())
    }

    @Test
    fun findsElementsFromElement() {
        driver.get(locatorsPage)
        val form = driver.findElement(By.tagName("form"))
        val elements = form.findElements(By.tagName("input"))
        for (e in elements) {
            println(e.getAttribute("value"))
        }

        assertTrue(elements.isNotEmpty())
    }

    @Test
    fun getsActiveElement() {
        driver.get(locatorsPage)
        driver.findElement(By.cssSelector("#fname")).sendKeys("webElement")
        val attr = driver.switchTo().activeElement().getAttribute("name")

        assertEquals("fname", attr)
    }

    @Test
    fun findsElementInShadowDom() {
        driver.get("https://www.selenium.dev/selenium/web/shadowRootPage.html")

        val shadowHost = driver.findElement(By.cssSelector("custom-checkbox-element"))
        val shadowRoot = shadowHost.shadowRoot
        val shadowContent = shadowRoot.findElement(By.cssSelector("input[type=checkbox]"))

        assertTrue(shadowContent.isDisplayed)
    }

    @BeforeEach
    fun configureImplicitWait() {
        driver.manage().timeouts().implicitlyWait(Duration.ofMillis(500))
    }
}

import pytest
from selenium import webdriver
from selenium.webdriver.common.by import By


def test_class_name():
    driver = webdriver.Chrome()
    driver.get("https://www.selenium.dev/selenium/web/locators_tests/locators.html")
    element = driver.find_element(By.CLASS_NAME, "information")

    assert element is not None
    assert element.tag_name == "input"

    driver.quit()

def test_css_selector(driver):
    driver = webdriver.Chrome()
    driver.get("https://www.selenium.dev/selenium/web/locators_tests/locators.html")
    element = driver.find_element(By.CSS_SELECTOR, "#fname")

    assert element is not None
    assert element.get_attribute("value") == "Jane"

    driver.quit()

def test_id(driver):
    driver = webdriver.Chrome()
    driver.get("https://www.selenium.dev/selenium/web/locators_tests/locators.html")
    element = driver.find_element(By.ID, "lname")

    assert element is not None
    assert element.get_attribute("value") == "Doe"

    driver.quit()

def test_name(driver):
    driver = webdriver.Chrome()
    driver.get("https://www.selenium.dev/selenium/web/locators_tests/locators.html")
    element = driver.find_element(By.NAME, "newsletter")

    assert element is not None
    assert element.tag_name == "input"

    driver.quit()

def test_link_text(driver):
    driver = webdriver.Chrome()
    driver.get("https://www.selenium.dev/selenium/web/locators_tests/locators.html")
    element = driver.find_element(By.LINK_TEXT, "Selenium Official Page")

    assert element is not None
    assert element.get_attribute("href") == "https://www.selenium.dev/"

    driver.quit()

def test_partial_link_text(driver):
    driver = webdriver.Chrome()
    driver.get("https://www.selenium.dev/selenium/web/locators_tests/locators.html")
    element = driver.find_element(By.PARTIAL_LINK_TEXT, "Official Page")

    assert element is not None
    assert element.get_attribute("href") == "https://www.selenium.dev/"

    driver.quit()

def test_tag_name(driver):
    driver = webdriver.Chrome()
    driver.get("https://www.selenium.dev/selenium/web/locators_tests/locators.html")
    element = driver.find_element(By.TAG_NAME, "a")

    assert element is not None
    assert element.get_attribute("href") == "https://www.selenium.dev/"

    driver.quit()

def test_xpath(driver):
    driver = webdriver.Chrome()
    driver.get("https://www.selenium.dev/selenium/web/locators_tests/locators.html")
    element = driver.find_element(By.XPATH, "//input[@value='f']")

    assert element is not None
    assert element.get_attribute("type") == "radio"

    driver.quit()

# frozen_string_literal: true

require 'spec_helper'

RSpec.describe 'Element Locators', skip: 'These are reference following the documentation example' do
  it 'finds element by class name' do
    driver.find_element(class: 'information')
  end

  it 'finds element by css selector' do
    driver.find_element(css: '#fname')
  end

  it 'finds element by id' do
    driver.find_element(id: 'lname')
  end

  it 'find element by name' do
    driver.find_element(name: 'newsletter')
  end

  it 'finds element by link text' do
    driver.find_element(link_text: 'Selenium Official Page')
  end

  it 'finds element by partial link text' do
    driver.find_element(partial_link_text: 'Official Page')
  end

  it 'finds element by tag name' do
    driver.find_element(tag_name: 'a')
  end

  it 'finds element by xpath' do
    driver.find_element(xpath: "//input[@value='f']")
  end

  context 'with relative locators' do
    it 'finds element above' do
      driver.find_element({relative: {tag_name: 'input', above: {id: 'password'}}})
    end

    it 'finds element below' do
      driver.find_element({relative: {tag_name: 'input', below: {id: 'email'}}})
    end

    it 'finds element to the left' do
      driver.find_element({relative: {tag_name: 'button', left: {id: 'submit'}}})
    end

    it 'finds element to the right' do
      driver.find_element({relative: {tag_name: 'button', right: {id: 'cancel'}}})
    end

    it 'finds near element' do
      driver.find_element({relative: {tag_name: 'input', near: {id: 'lbl-email'}}})
    end

    it 'chains relative locators' do
      driver.find_element({relative: {tag_name: 'button', below: {id: 'email'}, right: {id: 'cancel'}}})
    end
  end
end

const {By, Builder} = require('selenium-webdriver');
const assert = require("assert");

describe('Element Locator Test', function () {
  it('Check if element can be found by class name', async () => {
    let driver = await new Builder().forBrowser('chrome').build();
    await driver.get('https://www.selenium.dev/selenium/web/locators_tests/locators.html');
    const element = await driver.findElement(By.className('information'));
    const tag = await element.getTagName();
    const id = await element.getAttribute("id");
    const value = await element.getAttribute("value");

    assert.equal(tag, "input");
    assert.equal(id, "fname");
    assert.equal(value, "Jane");
    await driver.quit();
  });

  it('Check if element can be found by css selector', async function () {
    let driver = await new Builder().forBrowser('chrome').build();
    await driver.get('https://www.selenium.dev/selenium/web/locators_tests/locators.html');
    const element = await driver.findElement(By.css('#fname'));

    const tag = await element.getTagName();
    const id = await element.getAttribute("id");
    const value = await element.getAttribute("value");

    assert.equal(tag, "input");
    assert.equal(id, "fname");
    assert.equal(value, "Jane");
    await driver.quit();
  });

  it('Check if element can be found by id', async function () {
    let driver = await new Builder().forBrowser('chrome').build();
    await driver.get('https://www.selenium.dev/selenium/web/locators_tests/locators.html');
    const element = await driver.findElement(By.id('lname'));

    const tag = await element.getTagName();
    const id = await element.getAttribute("id");
    const value = await element.getAttribute("value");

    assert.equal(tag, "input");
    assert.equal(id, "lname");
    assert.equal(value, "Doe");
    await driver.quit();
  });

  it('Check if element can be found by name', async function () {
    let driver = await new Builder().forBrowser('chrome').build();
    await driver.get('https://www.selenium.dev/selenium/web/locators_tests/locators.html');
    const element = await driver.findElement(By.name("newsletter"));

    const tag = await element.getTagName();
    const type = await element.getAttribute("type");
    const value = await element.getAttribute("value");

    assert.equal(tag, "input");
    assert.equal(type, "checkbox");
    assert.equal(value, "1");
    await driver.quit();
  });



  it('Check if element can be found by link text', async function () {
    let driver = await new Builder().forBrowser('chrome').build();
    await driver.get('https://www.selenium.dev/selenium/web/locators_tests/locators.html');
    const element = await driver.findElement(By.linkText("Selenium Official Page"));

    const tag = await element.getTagName();
    const href = await element.getAttribute("href");

    assert.equal(tag, "a");
    assert.equal(href, "https://www.selenium.dev/");
    await driver.quit();
  });

  it('Check if element can be found by partial link text', async function () {
    let driver = await new Builder().forBrowser('chrome').build();
    await driver.get('https://www.selenium.dev/selenium/web/locators_tests/locators.html');
    const element = await driver.findElement(By.partialLinkText("Official Page"));

    const tag = await element.getTagName();
    const href = await element.getAttribute("href");

    assert.equal(tag, "a");
    assert.equal(href, "https://www.selenium.dev/");
    await driver.quit();
  });

  it('Check if element can be found by tag name', async function () {
    let driver = await new Builder().forBrowser('chrome').build();
    await driver.get('https://www.selenium.dev/selenium/web/locators_tests/locators.html');
    const element = await driver.findElement(By.tagName("a"));

    const tag = await element.getTagName();
    const text = await element.getText();

    assert.equal(tag, "a");
    assert.equal(text, "Selenium Official Page");
    await driver.quit();
  });

  it('Check if element can be found by xpath', async function () {
    let driver = await new Builder().forBrowser('chrome').build();
    await driver.get('https://www.selenium.dev/selenium/web/locators_tests/locators.html');
    const element = await driver.findElement(By.xpath('//input[@value="f"]'));

    const tag = await element.getTagName();
    const type = await element.getAttribute("type");
    const value = await element.getAttribute("value");

    assert.equal(tag, "input");
    assert.equal(type, "radio");
    assert.equal(value, "f");
    await driver.quit();
  });
});