page-object-patterns

Page Object Model Excellence

Advanced POM Architecture

• Inheritance Hierarchy: BasePage class with common functionality
• Component Pattern: Reusable UI components across pages
• Fluent Interface: Method chaining for readable test code
• Smart Locators: Dynamic locator strategies with fallbacks

Base Page Implementation

from typing import Optional, List, Union, Tuple
from selenium.webdriver.remote.webelement import WebElement
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.common.by import By
from selenium.webdriver.common.action_chains import ActionChains
from selenium.common.exceptions import TimeoutException, StaleElementReferenceException
import logging

logger = logging.getLogger(__name__)

class BasePage:
    """Enhanced base page with advanced interaction methods."""
    
    def __init__(self, driver, timeout: int = 10):
        self.driver = driver
        self.wait = WebDriverWait(driver, timeout)
        self.timeout = timeout
        self.actions = ActionChains(driver)
    
    def find_element_safely(self, locator: Tuple[str, str], timeout: Optional[int] = None) -> Optional[WebElement]:
        """Find element with comprehensive error handling and retry logic."""
        timeout = timeout or self.timeout
        wait = WebDriverWait(self.driver, timeout)
        
        try:
            element = wait.until(EC.presence_of_element_located(locator))
            logger.debug(f"Element found successfully: {locator}")
            return element
        except TimeoutException:
            logger.warning(f"Element not found within {timeout}s: {locator}")
            return None
        except StaleElementReferenceException:
            logger.warning(f"Stale element detected, retrying: {locator}")
            return self.find_element_safely(locator, timeout)
    
    def click_when_clickable(self, locator: Tuple[str, str], timeout: Optional[int] = None) -> bool:
        """Click element only when it's clickable with retry logic."""
        timeout = timeout or self.timeout
        wait = WebDriverWait(self.driver, timeout)
        
        try:
            element = wait.until(EC.element_to_be_clickable(locator))
            
            # Scroll element into view before clicking
            self.driver.execute_script("arguments[0].scrollIntoView(true);", element)
            
            # Use Actions for more reliable clicking
            self.actions.move_to_element(element).click().perform()
            logger.info(f"Successfully clicked element: {locator}")
            return True
        except TimeoutException:
            logger.error(f"Element not clickable: {locator}")
            return False
        except Exception as e:
            logger.error(f"Click failed for {locator}: {str(e)}")
            return False
    
    def enter_text_safely(self, locator: Tuple[str, str], text: str, 
                         clear_first: bool = True, validate: bool = True) -> bool:
        """Enter text with validation and error handling."""
        element = self.find_element_safely(locator)
        if not element:
            return False
        
        try:
            # Scroll to element and focus
            self.driver.execute_script("arguments[0].scrollIntoView(true);", element)
            element.click()  # Focus the element
            
            if clear_first:
                element.clear()
            
            element.send_keys(text)
            
            # Verify text was entered correctly if validation is enabled
            if validate:
                entered_value = element.get_attribute('value')
                if entered_value == text:
                    logger.info(f"Text entered successfully: '{text}' in {locator}")
                    return True
                else:
                    logger.warning(f"Text entry verification failed. Expected: '{text}', Got: '{entered_value}'")
                    return False
            
            logger.info(f"Text entered (no validation): '{text}' in {locator}")
            return True
                
        except Exception as e:
            logger.error(f"Failed to enter text in {locator}: {str(e)}")
            return False