Embracing the Power of Page Object Model (POM) in Python Test Automation

In my exciting journey as a software tester, I encountered challenges in maintaining test scripts without a structured approach (I never did it myself rather inherited such). But fear not! I discovered a solution that transformed my testing game - the Page Object Model (POM). Join me on this adventure as I explore the core principles, advantages, and practical implementation patterns of POM in Python. Get ready to unlock the potential of POM and witness how it streamlines test frameworks like never before.

Understanding the Page Object Model (POM)

The Page Object Model is my ally in Python test automation. Its elegance lies in separating test logic from page elements and interactions, creating a modular and maintainable framework.

Let me introduce you to "page objects," the building blocks of POM. These encapsulate web page interactions, making test case creation a breeze.

# Example of a page object for the login pagefrom selenium.webdriver.common.by import By

class LoginPage:
    def __init__(self, driver):
        self.driver = driver

    # Element locators
    USERNAME_INPUT = (By.ID, 'username')
    PASSWORD_INPUT = (By.ID, 'password')
    LOGIN_BUTTON = (By.ID, 'login_button')

    # Page methods 
    def enter_username(self, username):
        self.driver.find_element(*self.USERNAME_INPUT).send_keys(username)

    def enter_password(self, password):
        self.driver.find_element(*self.PASSWORD_INPUT).send_keys(password)

    def click_login_button(self):
        self.driver.find_element(*self.LOGIN_BUTTON).click()

(I highly advise to override the clumsy selenium click() method with your own implementation of fluent_click() !)

Advantages of Implementing the Page Object Model

It enhances code reusability, readability, and test maintenance. Say goodbye to tangled test cases and embrace the ease of parallel test execution and increased collaboration between developers and testers.

# Example of a test case using POM
import pytest
from selenium import webdriver
from pages.login_page import LoginPage

@pytest.mark.usefixtures("init_browser")
class TestLoginPage:
    def test_valid_login(self):
        driver = self.driver
        login_page = LoginPage(driver)
        login_page.enter_username("my_username")
        login_page.enter_password("my_password")
        login_page.click_login_button()
        # Add assertions and verifications here

Implementing POM Patterns

Now, let's dive into practical implementation! The Base Page Object Pattern is my go-to foundation, holding common functionalities across multiple page objects. Each individual page object shines with element locators and methods for seamless interactions.

# Example of a Base Page object for common functionalities 

class BasePage:
    def __init__(self, driver):
        self.driver = driver

    # Common methods for all page objects can be defined here
def navigate_to_url(self, url):
        self.driver.get(url)

def fluent_click(self, locator): #covered later
"""Perform fluent click using WebDriverWait."""
        element = WebDriverWait(self.driver, 10).until(EC.element_to_be_clickable(locator))
        element.click()

Challenges and Solutions in POM Implementation

No journey is without challenges. Dynamic elements are so common nowadays (React library is actually handling most stuff very neatly. Pretty handy thing is React Common Library functionality that we can use for our advantage building separate module called Component and reuse). Together we'll conquer asynchronous operations, ensuring rock-solid test execution in Python.

# Example of handling dynamic elements with WebDriverWait in POMfrom selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

class DynamicElementPage:
    def __init__(self, driver):
        self.driver = driver

    def wait_for_element_to_be_visible(self, locator):
        return WebDriverWait(self.driver, 10).until(
            EC.visibility_of_element_located(locator)
        )

Introducing the Factory Pattern for Page Objects

Enter the Factory Pattern, perfect companion to POM in Python. Discover its role in creating page objects dynamically, adding an extra layer of flexibility. Experience how the Factory Pattern complements POM, enhancing test automation's maintainability and scalability.

Probably at this moment you scratch your head "what is that Factory Pattern?" - well there is few more patterns in programming

Like for example Builder or dreaded Singleton. But answering your query in simple words the Factory Pattern is a design pattern that helps us create objects without specifying their exact class directly. It uses a separate "factory" method or class to handle object creation, making our code more flexible and easier to maintain.

In test automation, it's useful for dynamically creating different page objects or components during testing, improving code readability and reusability.

Hence an example of factory could look like this:

# Example of Factory Pattern for creating page objects
class PageFactory:
    def __init__(self, driver):
        self.driver = driver

    def create_page(self, page_name):
        if page_name == "login":
            return LoginPage(self.driver)
        elif page_name == "home":
            return HomePage(self.driver)
        # Add more page objects here as needed

And use it for example like this:

# Test case using the PageFactory to create page objects
def test_login_successful():
    driver = webdriver.Chrome()
    page_factory = PageFactory(driver)

    # Create a LoginPage instance using the factory
    login_page = page_factory.create_page("login")

    # Perform actions on the LoginPage
    login_page.enter_username("username")
    login_page.enter_password("password")
    login_page.click_login_button()

    # Verify the successful login
    assert login_page.is_login_successful()

    driver.quit()

Best Practices for Successful POM Implementation

Success thrives on best practices! Let me share the secrets to making your POM implementation shine. Embrace the golden rule of DRY (Don't Repeat Yourself), keeping your codebase clean and efficient.

Regularly maintain page objects to stay ahead of UI changes.

With the Factory Pattern by its side, POM empowers QAs to achieve efficient and maintainable test suites. Join me in embracing the power of POM and the Factory Pattern, unlocking the magic of test automation in Python.

Happy testing!