The Ultimate Selenium Testing Cheatsheet

# ── Installation (Python) ──
pip install selenium webdriver-manager

# Installation (Java — Maven)
# Add to pom.xml:
#   org.seleniumhq.selenium : selenium-java : 4.20+

# Installation (JavaScript/Node.js)
npm install selenium-webdriver

# ── Python Setup ──
from selenium import webdriver
from selenium.webdriver.chrome.service import Service
from selenium.webdriver.chrome.options import Options
from selenium.webdriver.common.by import By
from webdriver_manager.chrome import ChromeDriverManager

# ── Quick Start (auto-manages driver) ──
driver = webdriver.Chrome(service=Service(ChromeDriverManager().install()))
driver.get("https://www.example.com")
driver.quit()

# ── With Options ──
options = Options()
options.add_argument("--headless=new")       # headless mode
options.add_argument("--window-size=1920,1080")
options.add_argument("--disable-gpu")
options.add_argument("--no-sandbox")
options.add_argument("--disable-dev-shm-usage")
options.add_argument("--start-maximized")
options.add_experimental_option("excludeSwitches", ["enable-automation"])
options.add_experimental_option("useAutomationExtension", False)
options.add_argument("user-agent=Mozilla/5.0 (Custom Bot)")

# Disable images for speed
prefs = {"profile.managed_default_content_settings.images": 2}
options.add_experimental_option("prefs", prefs)

driver = webdriver.Chrome(
    service=Service(ChromeDriverManager().install()),
    options=options
)

// ── Java Setup ──
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.chrome.ChromeOptions;
import io.github.bonigarcia.wdm.WebDriverManager;

// Auto-manage driver with WebDriverManager
WebDriverManager.chromedriver().setup();
ChromeOptions options = new ChromeOptions();
options.addArguments("--headless=new");
options.addArguments("--window-size=1920,1080");
options.addArguments("--no-sandbox");

WebDriver driver = new ChromeDriver(options);
driver.get("https://www.example.com");

// ── Firefox Setup ──
// WebDriverManager.firefoxdriver().setup();
// WebDriver driver = new FirefoxDriver();

// ── Edge Setup ──
// WebDriverManager.edgedriver().setup();
// WebDriver driver = new EdgeDriver();

// ── Safari Setup (macOS only, no driver needed) ──
// WebDriver driver = new SafariDriver();

driver.quit();

// ── JavaScript/Node.js Setup ──
const { Builder, Browser, By, Key, until } = require('selenium-webdriver');

async function example() {
  let driver = await new Builder()
    .forBrowser(Browser.CHROME)
    .setChromeOptions(new chrome.Options().headless())
    .build();

  try {
    await driver.get('https://www.example.com');
    let title = await driver.getTitle();
    console.log('Page title:', title);
  } finally {
    await driver.quit();
  }
}

example();

# ── Selenium Locators (Python) ──
from selenium.webdriver.common.by import By

# ID — most reliable
driver.find_element(By.ID, "username")
driver.find_elements(By.ID, "item")        # returns list

# Name
driver.find_element(By.NAME, "email")
driver.find_element(By.NAME, "search-query")

# Class Name (single class)
driver.find_element(By.CLASS_NAME, "btn-primary")
driver.find_elements(By.CLASS_NAME, "list-item")

# Tag Name
driver.find_element(By.TAG_NAME, "h1")
driver.find_elements(By.TAG_NAME, "a")

# CSS Selector — powerful
driver.find_element(By.CSS_SELECTOR, "#submit-btn")
driver.find_element(By.CSS_SELECTOR, ".card .title")
driver.find_element(By.CSS_SELECTOR, "input[name='email']")
driver.find_element(By.CSS_SELECTOR, "div > ul > li:first-child")
driver.find_element(By.CSS_SELECTOR, "[data-testid='login']")

# XPath — most flexible
driver.find_element(By.XPATH, "//input[@id='username']")
driver.find_element(By.XPATH, "//button[contains(text(), 'Submit')]")
driver.find_element(By.XPATH, "//div[@class='card']//h3")
driver.find_element(By.XPATH, "//input[starts-with(@name, 'user_')]")
driver.find_element(By.XPATH, "//table//tr[td[text()='Alice']]")
driver.find_element(By.XPATH, "(//div[@class='item'])[2]")

# Link Text (exact)
driver.find_element(By.LINK_TEXT, "Sign In")

# Partial Link Text
driver.find_element(By.PARTIAL_LINK_TEXT, "Sign")

// ── Selenium Locators (Java) ──
import org.openqa.selenium.By;
import org.openqa.selenium.WebElement;

// ID
WebElement email = driver.findElement(By.id("email"));

// CSS Selector
WebElement btn = driver.findElement(By.cssSelector(".btn.btn-primary"));

// XPath
WebElement user = driver.findElement(By.xpath("//span[contains(@class, 'name')]"));

// Multiple elements
List<WebElement> items = driver.findElements(By.cssSelector(".list-item"));
for (WebElement item : items) {
    System.out.println(item.getText());
}

// Nested find
WebElement table = driver.findElement(By.id("data-table"));
List<WebElement> rows = table.findElements(By.tagName("tr"));
WebElement firstCell = rows.get(0).findElement(By.tagName("td"));

// Relative locators (Selenium 4+)
WebElement emailField = driver.findElement(By.id("email"));
// toRightOf, toLeftOf, above, below, near
WebElement submitBtn = driver.findElement(
    By.cssSelector("input[type='submit']"),
    Selenium4RelativeLocators
);
WebElement submit = driver.findElement(RelativeLocator.with(By.tagName("button"))
    .below(emailField)
    .toRightOf(passwordField));

# ── Advanced Locator Patterns ──

# ── Parent/Child Traversal ──
# XPath axes
driver.find_element(By.XPATH, "//td[text()='Alice']/..")         # parent
driver.find_element(By.XPATH, "//table//child::tr")                # children
driver.find_element(By.XPATH, "//div[@class='card']//following-sibling::div")
driver.find_element(By.XPATH, "//div[@class='card']//ancestor::form")

# ── Text-based selection ──
driver.find_element(By.XPATH, "//button[normalize-space()='Submit']")
driver.find_element(By.XPATH, "//div[contains(text(), 'Welcome')]")
driver.find_element(By.XPATH, "//*[text()='Hello']/following-sibling::*")

# ── Attribute-based ──
driver.find_element(By.XPATH, "//input[contains(@class, 'active')]")
driver.find_element(By.XPATH, "//a[contains(@href, '/users')]")
driver.find_element(By.XPATH, "//div[@role='alert']")

# ── CSS vs XPath Quick Reference ──
# ID:          By.ID, "user"        == CSS: "#user"
# Class:       By.CLASS, "btn"      == CSS: ".btn"
# Attribute:   By.CSS, "[name=x]"   == XPath: "//input[@name='x']"
# Contains:    CSS only w/:has()    == XPath: "[contains(., 'text')]"
# Parent:      No CSS parent        == XPath: "/.."
# Sibling:     CSS ~ (general)      == XPath: "/following-sibling"

# ── Basic Actions (Python) ──
from selenium.webdriver.common.by import By
from selenium.webdriver.common.keys import Keys
from selenium.webdriver.common.action_chains import ActionChains
from selenium.webdriver.support.ui import Select
from selenium.webdriver.support.ui import WebDriverWait

# ── Clicking ──
element = driver.find_element(By.ID, "submit-btn")
element.click()
# or
driver.find_element(By.ID, "submit-btn").click()

# ── Typing / Send Keys ──
input_field = driver.find_element(By.ID, "username")
input_field.clear()
input_field.send_keys("alice@example.com")
input_field.send_keys(Keys.ENTER)        # press Enter
input_field.send_keys(Keys.TAB)          # press Tab
input_field.send_keys(Keys.CONTROL, "a") # Ctrl+A (select all)
input_field.send_keys(Keys.CONTROL, "c") # Ctrl+C (copy)
input_field.send_keys(Keys.BACKSPACE)    # backspace
input_field.send_keys("hello" + Keys.TAB + "world")  # chain keys

# ── Text Input Methods ──
input_field.send_keys("")                # clear via send_keys (some drivers)
input_field.clear()                      # recommended clear

# ── Get Element Information ──
element.text                             # inner text
element.get_attribute("href")            # attribute value
element.get_attribute("class")           # class attribute
element.get_attribute("data-testid")     # data attribute
element.tag_name                         # tag name
element.is_displayed()                   # visible?
element.is_enabled()                     # enabled?
element.is_selected()                    # selected (checkbox)?
element.get_property("value")            # JavaScript property
element.size                             # {'width': 300, 'height': 40}
element.location                         # {'x': 100, 'y': 200}
element.rect                             # size + location combined

# ── Dropdowns (Select) ──
dropdown = Select(driver.find_element(By.ID, "country"))
dropdown.select_by_visible_text("United States")
dropdown.select_by_value("us")
dropdown.select_by_index(2)
dropdown.deselect_all()                  # multi-select only
dropdown.options                         # list of all options
dropdown.first_selected_option           # currently selected

# ── ActionChains — Advanced Interactions ──
from selenium.webdriver.common.action_chains import ActionChains
from selenium.webdriver.common.keys import Keys

actions = ActionChains(driver)

# ── Mouse Actions ──
# Click
actions.click(element).perform()

# Double click
actions.double_click(element).perform()

# Right click (context menu)
actions.context_click(element).perform()

# Move to element (hover)
actions.move_to_element(hover_target).perform()

# Click and hold
actions.click_and_hold(element).release().perform()

# Drag and drop
source = driver.find_element(By.ID, "draggable")
target = driver.find_element(By.ID, "dropzone")
actions.drag_and_drop(source, target).perform()

# Drag by offset
actions.drag_and_drop_by_offset(source, 100, 50).perform()

# Move by offset
actions.move_by_offset(10, 20).perform()

# ── Keyboard Actions ──
actions.key_down(Keys.CONTROL).send_keys("a").key_up(Keys.CONTROL).perform()
actions.send_keys("hello world").perform()

# Key combinations
actions.key_down(Keys.SHIFT).send_keys("hello").key_up(Keys.SHIFT).perform()

# ── Combined Actions ──
actions.move_to_element(menu).click(submenu_item).perform()
actions.move_to_element(slider).click_and_hold().move_by_offset(50, 0).release().perform()

# ── JavaScript Execution ──
# Execute script
result = driver.execute_script("return document.title;")
driver.execute_script("arguments[0].scrollIntoView(true);", element)
driver.execute_script("window.scrollTo(0, document.body.scrollHeight);")
driver.execute_script("document.querySelector('#hidden').style.display='block';")

# Execute async script
result = driver.execute_async_script(
    "var callback = arguments[arguments.length - 1]; "
    "setTimeout(function() { callback('done'); }, 1000);"
)

# ── File Upload ──
file_input = driver.find_element(By.CSS_SELECTOR, "input[type='file']")
file_input.send_keys("/path/to/file.pdf")

# ── Cookies ──
driver.add_cookie({"name": "session", "value": "abc123"})
cookie = driver.get_cookie("session")
all_cookies = driver.get_cookies()
driver.delete_cookie("session")
driver.delete_all_cookies()

# ── Implicit Wait ──
# Sets global timeout for find_element() — applies to ALL finds
# Only needs to be set ONCE per driver session
driver.implicitly_wait(10)  # 10 seconds max

# Now any find_element will poll for up to 10 seconds
element = driver.find_element(By.ID, "slow-element")  # retries for 10s
# ⚠️ Do NOT mix implicit and explicit waits!

# ── Explicit Wait (WebDriverWait) — RECOMMENDED ──
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

wait = WebDriverWait(driver, 10)  # 10 second timeout

# Wait for element to be present in DOM
element = wait.until(
    EC.presence_of_element_located((By.ID, "dynamic-element"))
)

# Wait for element to be clickable
button = wait.until(
    EC.element_to_be_clickable((By.CSS_SELECTOR, "#submit-btn"))
)
button.click()

# Wait for element to be visible
element = wait.until(
    EC.visibility_of_element_located((By.CLASS_NAME, "notification"))
)

# Wait for element to be invisible (disappear)
wait.until(
    EC.invisibility_of_element_located((By.ID, "loading-spinner"))
)

# Wait for text to be present
wait.until(
    EC.text_to_be_present_in_element((By.ID, "status"), "Complete")
)

# Custom wait condition
def element_has_count(driver, locator, count):
    elements = driver.find_elements(*locator)
    return len(elements) == count

wait.until(lambda d: element_has_count(d, (By.CLASS_NAME, "item"), 5))

# ── Expected Conditions Reference ──
from selenium.webdriver.support import expected_conditions as EC

# ── Element State ──
EC.presence_of_element_located(locator)       # In DOM (not necessarily visible)
EC.visibility_of_element_located(locator)     # Visible and has size > 0
EC.visibility_of(element)                     # Same but pass WebElement
EC.element_to_be_clickable(locator)           # Visible + enabled
EC.invisibility_of_element_located(locator)   # Hidden or not in DOM
EC.staleness_of(element)                      # Element is no longer attached to DOM

# ── Text & Value ──
EC.text_to_be_present_in_element(locator, text)       # Inner text contains
EC.text_to_be_present_in_element_value(locator, text)  # Input value contains

# ── Selection & Attributes ──
EC.element_to_be_selected(element)          # Checkbox/radio is selected
EC.element_selection_state_to_be(element, is_selected)

# ── Frames ──
EC.frame_to_be_available_and_switch_to_it(locator)

# ── Alerts ──
EC.alert_is_present()                       # Alert dialog is present

# ── Number of Elements ──
def at_least_n_elements(locator, n):
    def _predicate(driver):
        return len(driver.find_elements(*locator)) >= n
    return _predicate

wait.until(at_least_n_elements((By.CLASS_NAME, "row"), 10))

# ── Custom Expected Condition Class ──
class element_has_css_class:
    def __init__(self, locator, css_class):
        self.locator = locator
        self.css_class = css_class

    def __call__(self, driver):
        element = driver.find_element(*self.locator)
        if self.css_class in element.get_attribute("class"):
            return element
        return False

wait.until(element_has_css_class((By.ID, "card"), "active"))

// ── Java FluentWait (Selenium 4+) ──
import org.openqa.selenium.support.ui.FluentWait;
import org.openqa.selenium.support.ui.Wait;
import java.time.Duration;

Wait<WebDriver> wait = new FluentWait<>(driver)
    .withTimeout(Duration.ofSeconds(30))      // total timeout
    .pollingEvery(Duration.ofMillis(500))     // poll interval
    .ignoring(NoSuchElementException.class)   // ignore specific exceptions
    .ignoring(StaleElementReferenceException.class)
    .withMessage("Element not found within timeout");

WebElement element = wait.until(d -> {
    WebElement el = d.findElement(By.id("dynamic"));
    return el.isDisplayed() ? el : null;
});

// ── Python FluentWait equivalent ──
from selenium.webdriver.support.ui import WebDriverWait

wait = WebDriverWait(
    driver,
    timeout=30,
    poll_frequency=0.5,  # poll every 0.5 seconds
    ignored_exceptions=[NoSuchElementException, StaleElementReferenceException]
)

# ── iframe Handling ──
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

# Switch to iframe by name/id
driver.switch_to.frame("iframe-name")
# Switch to iframe by index
driver.switch_to.frame(0)
# Switch to iframe by WebElement
iframe_element = driver.find_element(By.CSS_SELECTOR, "iframe#my-frame")
driver.switch_to.frame(iframe_element)

# Now interact with elements inside the iframe
driver.find_element(By.ID, "inner-button").click()

# Switch back to main page
driver.switch_to.default_content()

# Switch to parent frame (nested iframes)
driver.switch_to.parent_frame()

# ── Wait for frame and switch ──
wait = WebDriverWait(driver, 10)
wait.until(EC.frame_to_be_available_and_switch_to_it(
    (By.ID, "my-iframe")
))

# ── Window / Tab Handling ──
# Open new window/tab
driver.execute_script("window.open('https://example.com', '_blank');")

# Get all window handles
handles = driver.window_handles
# handles[0] = original, handles[1] = new tab

# Switch to new window
driver.switch_to.window(handles[1])

# Switch back to original
driver.switch_to.window(handles[0])

# Close current window/tab
driver.close()

# Switch to the remaining window after close
driver.switch_to.window(driver.window_handles[0])

# ── Window Management ──
# Maximize window
driver.maximize_window()

# Minimize window
driver.minimize_window()

# Full screen
driver.fullscreen_window()

# Set window size
driver.set_window_size(1280, 720)

# Set window position
driver.set_window_position(100, 100)

# Get window size
size = driver.get_window_size()
print(f"Width: {size['width']}, Height: {size['height']}")

# Get window position
position = driver.get_window_position()

# ── Alert / Confirm / Prompt Dialogs ──
from selenium.webdriver.support import expected_conditions as EC

# Wait for alert
alert = wait.until(EC.alert_is_present())

# Get alert text
text = alert.text

# Accept (click OK)
alert.accept()

# Dismiss (click Cancel)
alert.dismiss()

# Type into prompt
alert.send_keys("Hello")

# ── Navigation Commands ──
driver.get("https://example.com")           # Navigate to URL
driver.back()                                # Browser back
driver.forward()                             # Browser forward
driver.refresh()                             # Refresh page

# Get current URL
current_url = driver.current_url

# Get page title
title = driver.title

# Get page source (HTML)
source = driver.page_source

# ── JavaScript Scrolling ──
# Scroll to bottom
driver.execute_script("window.scrollTo(0, document.body.scrollHeight);")

# Scroll to element
element = driver.find_element(By.ID, "footer")
driver.execute_script("arguments[0].scrollIntoView({behavior: 'smooth', block: 'center'});", element)

# Scroll by pixels
driver.execute_script("window.scrollBy(0, 500);")

# Scroll to top
driver.execute_script("window.scrollTo(0, 0);")

# ── Assertions with Python unittest + Selenium ──
import unittest

class TestLogin(unittest.TestCase):
    def setUp(self):
        self.driver = webdriver.Chrome(
            service=Service(ChromeDriverManager().install())
        )
        self.driver.implicitly_wait(10)

    def test_page_title(self):
        self.driver.get("https://example.com")
        self.assertIn("Example", self.driver.title)
        self.assertEqual("Example Domain", self.driver.title)

    def test_element_visible(self):
        self.driver.get("https://example.com")
        heading = self.driver.find_element(By.TAG_NAME, "h1")
        self.assertTrue(heading.is_displayed())
        self.assertEqual(heading.text, "Example Domain")

    def test_element_exists(self):
        elements = self.driver.find_elements(By.ID, "non-existent")
        self.assertEqual(len(elements), 0)

    def test_element_attribute(self):
        link = self.driver.find_element(By.TAG_NAME, "a")
        self.assertEqual(link.get_attribute("href"), "https://www.iana.org/domains/example")

    def test_input_value(self):
        field = self.driver.find_element(By.ID, "search")
        field.send_keys("selenium")
        self.assertEqual(field.get_attribute("value"), "selenium")

    def test_element_enabled(self):
        button = self.driver.find_element(By.ID, "submit")
        self.assertTrue(button.is_enabled())
        self.assertFalse(button.is_selected())

    def test_url(self):
        self.driver.get("https://example.com/page")
        self.assertEqual(self.driver.current_url, "https://example.com/page")
        self.assertIn("/page", self.driver.current_url)

    def tearDown(self):
        self.driver.quit()

if __name__ == "__main__":
    unittest.main()

# ── Assertions with pytest (cleaner) ──
import pytest

@pytest.fixture
def driver():
    d = webdriver.Chrome(service=Service(ChromeDriverManager().install()))
    d.implicitly_wait(10)
    yield d
    d.quit()

def test_login_success(driver):
    driver.get("https://example.com/login")

    driver.find_element(By.ID, "email").send_keys("alice@test.com")
    driver.find_element(By.ID, "password").send_keys("pass123")
    driver.find_element(By.ID, "submit").click()

    # Assert URL changed
    assert "/dashboard" in driver.current_url

    # Assert welcome message
    welcome = driver.find_element(By.CSS_SELECTOR, ".welcome-msg")
    assert "Alice" in welcome.text
    assert welcome.is_displayed()

def test_form_validation(driver):
    driver.get("https://example.com/register")

    # Submit empty form
    driver.find_element(By.ID, "submit").click()

    # Assert error messages appear
    errors = driver.find_elements(By.CSS_SELECTOR, ".error-message")
    assert len(errors) >= 1
    assert any("required" in e.text.lower() for e in errors)

def test_table_data(driver):
    driver.get("https://example.com/users")

    rows = driver.find_elements(By.CSS_SELECTOR, "table tbody tr")
    assert len(rows) > 0

    # Check specific cell
    first_row = rows[0]
    cells = first_row.find_elements(By.TAG_NAME, "td")
    assert cells[0].text == "Alice"
    assert cells[1].text == "alice@test.com"

# ── Selenium Grid 4 (Standalone) ──
# Start grid (all-in-one)
java -jar selenium-server-4.20.0.jar standalone

# Start hub and nodes separately
java -jar selenium-server-4.20.0.jar hub
java -jar selenium-server-4.20.0.jar node --detect-drivers true

# Start with Docker
docker run -d -p 4442-4444:4442-4444 --net=host selenium/standalone-chrome:latest
docker run -d -p 4442-4444:4442-4444 --net=host selenium/standalone-firefox:latest

# Docker Compose (hub + multiple nodes)
docker compose up -d

# Check grid status
curl http://localhost:4444/status
# Open Grid UI: http://localhost:4444/ui

# ── Connecting to Remote WebDriver (Grid) ──
from selenium import webdriver
from selenium.webdriver.chrome.options import Options

options = Options()
options.add_argument("--start-maximized")
options.set_capability("browserName", "chrome")
options.set_capability("platformName", "linux")

# Connect to remote grid
driver = webdriver.Remote(
    command_executor="http://localhost:4444/wd/hub",
    options=options
)

driver.get("https://www.example.com")
print(f"Title: {driver.title}")
driver.quit()

# ── Cross-Browser Testing ──
def get_driver(browser="chrome"):
    from selenium.webdriver.chrome.options import Options as ChromeOpts
    from selenium.webdriver.firefox.options import Options as FirefoxOpts

    if browser == "chrome":
        options = ChromeOpts()
        options.browser_version = "120"
    elif browser == "firefox":
        options = FirefoxOpts()
        options.browser_version = "121"
    else:
        raise ValueError(f"Unsupported browser: {browser}")

    options.set_capability("platformName", "linux")
    return webdriver.Remote("http://grid:4444/wd/hub", options=options)

# ── Parallel Execution with pytest-xdist ──
# pytest -n auto --dist=each test_grid.py
# Each worker gets its own driver instance

# pytest.ini
# [pytest]
# addopts = -v --dist=each
#      - browser=chrome --grid-url=http://grid:4444/wd/hub

# ── docker-compose.yml for Selenium Grid ──
version: "3"
services:
  selenium-hub:
    image: selenium/hub:4.20.0
    container_name: selenium-hub
    ports:
      - "4442:4442"
      - "4443:4443"
      - "4444:4444"
    environment:
      - GRID_MAX_SESSION=10
      - GRID_BROWSER_TIMEOUT=60
      - GRID_TIMEOUT=120

  chrome:
    image: selenium/node-chrome:4.20.0
    depends_on:
      - selenium-hub
    environment:
      - SE_EVENT_BUS_HOST=selenium-hub
      - SE_EVENT_BUS_PUBLISH_PORT=4442
      - SE_EVENT_BUS_SUBSCRIBE_PORT=4443
      - SE_NODE_MAX_SESSIONS=5
    shm_size: '2gb'
    deploy:
      replicas: 3

  firefox:
    image: selenium/node-firefox:4.20.0
    depends_on:
      - selenium-hub
    environment:
      - SE_EVENT_BUS_HOST=selenium-hub
      - SE_EVENT_BUS_PUBLISH_PORT=4442
      - SE_EVENT_BUS_SUBSCRIBE_PORT=4443
    shm_size: '2gb'
    deploy:
      replicas: 2

# ── Page Object Model (POM) Pattern ──
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

class BasePage:
    """Base class for all page objects."""
    def __init__(self, driver):
        self.driver = driver
        self.wait = WebDriverWait(driver, 10)

    def find(self, locator):
        return self.wait.until(
            EC.visibility_of_element_located(locator)
        )

    def click(self, locator):
        self.find(locator).click()

    def type_text(self, locator, text):
        element = self.find(locator)
        element.clear()
        element.send_keys(text)

    def get_text(self, locator):
        return self.find(locator).text

    def is_visible(self, locator):
        try:
            return self.find(locator).is_displayed()
        except:
            return False


class LoginPage(BasePage):
    # Locators
    EMAIL = (By.ID, "email")
    PASSWORD = (By.ID, "password")
    SUBMIT = (By.CSS_SELECTOR, "button[type='submit']")
    ERROR = (By.CSS_SELECTOR, ".error-message")

    # Actions
    def load(self):
        self.driver.get("https://example.com/login")
        return self

    def login(self, email, password):
        self.type_text(self.EMAIL, email)
        self.type_text(self.PASSWORD, password)
        self.click(self.SUBMIT)
        return DashboardPage(self.driver)  # returns next page

    def get_error(self):
        return self.get_text(self.ERROR)


class DashboardPage(BasePage):
    WELCOME = (By.CSS_SELECTOR, ".welcome-msg")
    LOGOUT = (By.ID, "logout-btn")
    PROFILE_LINK = (By.CSS_SELECTOR, "a[href='/profile']")

    def get_welcome_text(self):
        return self.get_text(self.WELCOME)

    def logout(self):
        self.click(self.LOGOUT)
        return LoginPage(self.driver)

    def go_to_profile(self):
        self.click(self.PROFILE_LINK)
        return ProfilePage(self.driver)

# ── Tests with POM ──
import pytest

@pytest.fixture
def driver():
    d = webdriver.Chrome(service=Service(ChromeDriverManager().install()))
    d.maximize_window()
    yield d
    d.quit()

def test_login_success(driver):
    login = LoginPage(driver).load()
    dashboard = login.login("alice@test.com", "password123")
    assert "Alice" in dashboard.get_welcome_text()

def test_login_failure(driver):
    login = LoginPage(driver).load()
    login.login("wrong@test.com", "wrongpass")
    error = login.get_error()
    assert "Invalid" in error or "incorrect" in error.lower()

def test_logout(driver):
    login = LoginPage(driver).load()
    dashboard = login.login("alice@test.com", "password123")
    login_page = dashboard.logout()
    assert login_page.is_visible(LoginPage.EMAIL)

# ── Utility & Best Practice Patterns ──

# 1. Screenshot on failure (pytest conftest.py)
# conftest.py
import pytest

@pytest.hookimpl(hookwrapper=True)
def pytest_runtest_makereport(item, call):
    outcome = yield
    report = outcome.get_result()
    if report.when == "call" and report.failed:
        driver = item.funcargs["driver"]
        driver.save_screenshot(f"screenshots/{item.name}.png")

# 2. Take screenshot manually
driver.save_screenshot("screenshot.png")
element.screenshot("element.png")

# 3. Page Source on failure
with open("page_source.html", "w") as f:
    f.write(driver.page_source)

# 4. Reusable wait helper
def wait_for_url(driver, url_pattern, timeout=10):
    WebDriverWait(driver, timeout).until(
        lambda d: url_pattern in d.current_url
    )

# 5. Handle stale elements (retry pattern)
from selenium.common.exceptions import StaleElementReferenceException

def safe_click(driver, locator, retries=3):
    for _ in range(retries):
        try:
            element = WebDriverWait(driver, 5).until(
                EC.element_to_be_clickable(locator)
            )
            element.click()
            return True
        except StaleElementReferenceException:
            continue
    return False

# 6. Headless detection helper
def is_headless(driver):
    return driver.execute_script("return navigator.webdriver")