Page Object Model (POM): Clean and Reusable Test Code
The Problem POM Solves
Imagine 50 tests that all use the login button with the locator #login-button. One day the developer renames it. You must fix 50 tests. With the Page Object Model you fix one line.
Simple idea: Create one class for each page. The class knows the locators and the actions of that page. Tests only call methods such as
login(user, password). Tests describe what, page objects know how.
Without POM (messy)
python
def test_login(driver):
driver.get("https://www.saucedemo.com")
driver.find_element(By.ID, "user-name").send_keys("standard_user")
driver.find_element(By.ID, "password").send_keys("secret_sauce")
driver.find_element(By.ID, "login-button").click()
assert driver.find_element(By.CLASS_NAME, "title").text == "Products"
With POM
Folder layout:
text
project/
pages/
login_page.py
inventory_page.py
tests/
test_login.py
conftest.py
python
# pages/login_page.py
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
class LoginPage:
URL = "https://www.saucedemo.com"
USERNAME = (By.ID, "user-name")
PASSWORD = (By.ID, "password")
LOGIN_BTN = (By.ID, "login-button")
ERROR = (By.CSS_SELECTOR, "[data-test='error']")
def __init__(self, driver):
self.driver = driver
self.wait = WebDriverWait(driver, 10)
def open(self):
self.driver.get(self.URL)
return self
def login(self, username, password):
self.wait.until(EC.visibility_of_element_located(self.USERNAME)).send_keys(username)
self.driver.find_element(*self.PASSWORD).send_keys(password)
self.driver.find_element(*self.LOGIN_BTN).click()
from pages.inventory_page import InventoryPage
return InventoryPage(self.driver)
def get_error(self):
return self.wait.until(EC.visibility_of_element_located(self.ERROR)).text
python
# pages/inventory_page.py
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
class InventoryPage:
TITLE = (By.CLASS_NAME, "title")
ITEMS = (By.CLASS_NAME, "inventory_item")
ITEM_NAMES = (By.CLASS_NAME, "inventory_item_name")
def __init__(self, driver):
self.driver = driver
self.wait = WebDriverWait(driver, 10)
def title(self):
return self.wait.until(EC.visibility_of_element_located(self.TITLE)).text
def product_names(self):
return [e.text for e in self.driver.find_elements(*self.ITEM_NAMES)]
def product_count(self):
return len(self.driver.find_elements(*self.ITEMS))
python
# tests/test_login.py
from pages.login_page import LoginPage
def test_valid_login(driver):
inventory = LoginPage(driver).open().login("standard_user", "secret_sauce")
assert inventory.title() == "Products"
assert inventory.product_count() == 6
def test_locked_user(driver):
page = LoginPage(driver).open()
page.login("locked_out_user", "secret_sauce")
assert "locked out" in page.get_error()
Rules for Good Page Objects
| Rule | Reason |
|---|---|
| Locators live only in page classes | One place to fix |
Methods are named after user actions: login, add_to_cart | Tests read like a story |
| Methods return data or another page object | Allows chaining and clear flow |
| No assertions inside page objects (mostly) | The test decides what is a pass or fail. Small checks like is_loaded() are fine |
| Waits live inside page methods | Tests stay clean |
| One class per page or per big component (header, menu) | Small and reusable |
Fixture to Create Page Objects
python
@pytest.fixture
def login_page(driver):
return LoginPage(driver).open()
def test_empty_password(login_page):
login_page.login("standard_user", "")
assert "Password is required" in login_page.get_error()
Avoid the circular import trap: If
LoginPage imports InventoryPage at the top and the reverse also happens, Python raises an error. Import inside the method (as above) or avoid returning pages in one direction.
PageFactory? Java has
PageFactory and @FindBy. Python does not need it: plain tuples and methods are simple and enough.
Conclusion
The Page Object Model puts locators and page actions into classes so that tests read like instructions and maintenance is easy. One UI change means one code change.
Quick Summary: One class per page; tests call login(), not find_element().

