Verify navigation using XPath axes parent, child, and sibling

Preconditions (2)

Step 1: Open the sample webpage URL

Step 2: Locate the list item with text 'Item 2' using XPath child axis from the parent list

Step 3: From 'Item 2', navigate to its parent element and verify it is the list with id 'menu'

Step 4: From 'Item 2', locate its following sibling list item and verify its text is 'Item 3'

Step 5: From 'Item 2', locate its child sub-item with text 'Subitem 2.1' using XPath child axis

Step 6: Verify all located elements are displayed on the page

✅ Expected Result: The test should confirm that the XPath axes parent, child, and sibling correctly locate the elements and all elements are visible on the page

Automation Requirements - Selenium with Python

Assertions Needed:

Assert the parent element's id is 'menu'

Assert the following sibling's text is 'Item 3'

Assert the child sub-item's text is 'Subitem 2.1'

Assert all located elements are displayed

Best Practices:

Use explicit waits to wait for elements to be present and visible

Use By.XPATH with clear and maintainable XPath expressions

Avoid absolute XPath; use relative XPath with axes

Use Page Object Model pattern for element locators and actions

Automated Solution

Selenium Python

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

class MenuPage:
    def __init__(self, driver):
        self.driver = driver
        self.wait = WebDriverWait(driver, 10)

    def get_item_2(self):
        xpath = "//ul[@id='menu']/li[normalize-space(text())='Item 2']"
        return self.wait.until(EC.visibility_of_element_located((By.XPATH, xpath)))

    def get_parent_of_item_2(self):
        # Using parent axis
        xpath = "//ul[@id='menu']/li[normalize-space(text())='Item 2']/parent::ul"
        return self.wait.until(EC.visibility_of_element_located((By.XPATH, xpath)))

    def get_following_sibling_of_item_2(self):
        # Using following-sibling axis
        xpath = "//ul[@id='menu']/li[normalize-space(text())='Item 2']/following-sibling::li[1]"
        return self.wait.until(EC.visibility_of_element_located((By.XPATH, xpath)))

    def get_child_subitem_of_item_2(self):
        # Using child axis
        xpath = "//ul[@id='menu']/li[normalize-space(text())='Item 2']/child::ul/li[normalize-space(text())='Subitem 2.1']"
        return self.wait.until(EC.visibility_of_element_located((By.XPATH, xpath)))


def test_xpath_axes():
    driver = webdriver.Chrome()
    driver.get("https://example.com/sample-menu")  # Replace with actual URL

    menu_page = MenuPage(driver)

    item_2 = menu_page.get_item_2()
    assert item_2.is_displayed(), "Item 2 should be visible"

    parent = menu_page.get_parent_of_item_2()
    assert parent.get_attribute('id') == 'menu', f"Parent id should be 'menu', got {parent.get_attribute('id')}"

    sibling = menu_page.get_following_sibling_of_item_2()
    assert sibling.text.strip() == 'Item 3', f"Following sibling text should be 'Item 3', got {sibling.text.strip()}"

    child_subitem = menu_page.get_child_subitem_of_item_2()
    assert child_subitem.text.strip() == 'Subitem 2.1', f"Child subitem text should be 'Subitem 2.1', got {child_subitem.text.strip()}"
    assert child_subitem.is_displayed(), "Child subitem should be visible"

    driver.quit()

This script uses Selenium with Python to automate the test case for XPath axes.

The MenuPage class encapsulates element locators using XPath axes:

get_item_2: Locates 'Item 2' using a relative XPath child from the list with id 'menu'.
get_parent_of_item_2: Uses the parent:: axis to get the parent ul element of 'Item 2'.
get_following_sibling_of_item_2: Uses following-sibling:: axis to get the next sibling list item.
get_child_subitem_of_item_2: Uses child:: axis to get the nested sub-item 'Subitem 2.1'.

The test function test_xpath_axes opens the webpage, creates the page object, and performs assertions to verify:

Elements are visible
Parent element has correct id
Sibling and child elements have expected text

Explicit waits ensure elements are present and visible before interaction, improving test stability.

Common Mistakes - 3 Pitfalls

Using absolute XPath like /html/body/ul/li[2]

Not waiting for elements before accessing them

Using incorrect XPath axes syntax or mixing axes improperly

Bonus Challenge

Now add data-driven testing with 3 different list items: 'Item 1', 'Item 2', and 'Item 3', verifying their parent, sibling, and child elements accordingly.

Show Hint