Page Object Model and Page Factory in Selenium (Java)

In Selenium test automation, managing test scripts efficiently is important for improved scalability, readability, and maintainability. The Project Object Model (POM) is a design pattern that improves the structure of automation scripts by creating a separate class for each web page in an application. Page Factory is a more advanced version of POM that further simplifies object repository management.

Read this blog in detail to know more about the processes of Page Object Model and Page Factory, their way of implementation, benefits, challenges, etc.

What is the Page Object Model in Selenium?

The Project Object Model (POM) is a design pattern used in Selenium automation testing that promotes better code maintainability and reusability. In POM, each web page of the application is represented as a class, and the elements of the page are defined as variables. Some common methods based on the actions performed on these elements are also covered within the same class.

Advantages of using Page Object Model

• Once created, the page object class can be used across multiple test cases.
• Changes in the user interface need to be updated only in the particular page object, not in multiple test scripts.
• POM methods help in reducing code duplication.
• Code becomes more structured and easier to understand.
• Any UI changes will not affect the test logic, improving test reliability.

Methods Included in a Page Object Model

Here are some of the standard methods being used in the Project Object Model:

1. Locators

These are used to identify and locate web elements on a webpage.

Example:

By username = By.id("userName");
By password = By.id("password");
By loginButton = By.id("login");

2. Actions

These methods interact with the located web elements, such as entering text, clicking buttons, or retrieving values.

Example:

public void enterUsername(String user) {
    driver.findElement(username).sendKeys(user);
}
public void enterPassword(String pass) {
    driver.findElement(password).sendKeys(pass);
}
public void clickLogin() {
    driver.findElement(loginButton).click();
}

3. Navigation

This method directly helps to navigate between different pages of the application.

Example:

public void openLoginPage() {
    driver.get("https://example.com/login");
}

4. Validation

These methods verify if an action was performed successfully, such as checking if a login was successful.

Example:

public String getLoginErrorMessage() {
    return driver.findElement(By.id("errorMessage")).getText();
}

Also Read About: Selenium Locators Explained (with Types and Methods)

How to implement Page Object Model in Selenium?

Step 1: Create a Page Object Class by defining locators and methods for interacting with elements.

Step 2: Initialize Selenium WebDriver in the script.

Step 3: Call methods from the page object class to perform actions.

Step 4: Run the test script to validate functionality and expected output.

Example Code:

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;

public class LoginPage {
    WebDriver driver;
    By username = By.id("userName");
    By password = By.id("password");
    By loginButton = By.id("login")

    public LoginPage(WebDriver driver) {
        this.driver = driver;
    }
    public void enterUsername(String user) {
        driver.findElement(username).sendKeys(user);
    }

    public void enterPassword(String pass) {
        driver.findElement(password).sendKeys(pass);
    }

    public void clickLogin() {
        driver.findElement(loginButton).click();
    }
}

Usage in a Test Script

import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;

public class LoginTest {
    public static void main(String[] args) {
        WebDriver driver = new ChromeDriver();
        driver.get("https://www.thetesttribe.com/login");

        LoginPage loginPage = new LoginPage(driver);
        loginPage.enterUsername("testuser");
        loginPage.enterPassword("testpass");
        loginPage.clickLogin();

        driver.quit();
    }
}

What is the Page Factory in Selenium?

Page Factory is an extension of the Page Object Model (POM) in Selenium that simplifies object repository management by using annotations like @FindBy to initialize web elements, reducing the need for driver.findElement() calls. This overall improves the performance and reduces unnecessary memory consumption.

Using PageFactory.initElements(driver, this), all elements are automatically initialized, making the code cleaner and more readable. This approach improves maintainability by reducing duplicated code and provides a structured way to define and interact with web elements in automation scripts.

Benefits of using Page Factory in Selenium

• Elements are being called out only when they are used in the testing.
• Reduces code duplication, which creates no need for explicitly using driver.findElement().
• Improves code readability by providing a structured way to locate elements.
• Uses AjaxElementLocatorFactory to locate elements efficiently.

Check Out: Alert and Popup Handling in Selenium Using Simple Steps

How to implement Page Factory in Selenium?

Step 1: Create a Page Object Class by defining locators using @FindBy annotations.

Step 2: Initialize Selenium WebDriver to the Page Factory class.

Step 3: Use PageFactory.initElements() to initialize all elements.

Step 4: Define action methods to interact with the elements, such as entering text or clicking buttons.

Step 5: Use the Page Factory class in a test script and call its methods.

Step 6: Run all the test cases to validate functionality.

Example Code:

import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.support.FindBy;
import org.openqa.selenium.support.PageFactory;

public class LoginPageFactory {
    WebDriver driver;

    @FindBy(id = “userName”)
    WebElement username;

    @FindBy(id = “password”)
    WebElement password;

    @FindBy(id = “login”)
    WebElement loginButton;

    public LoginPageFactory(WebDriver driver) {
        this.driver = driver;
        PageFactory.initElements(driver, this);
    }

    public void login(String user, String pass) {
        username.sendKeys(user);
        password.sendKeys(pass);
        loginButton.click();
    }
}

Best Way to Structure your Selenium WebDriver project

• Create a Base Class: This class will handle WebDriver initialization and teardown.
  
• Develop Page Object Classes: Create a separate class for each page and define locators using @FindBy and methods for interactions.
  
• Organize Test Cases: Maintain test scripts in a separate directory and use meaningful test names for better readability.
  
• Use Utility Classes: Store reusable methods like handling waits, taking screenshots, and reading configurations.
  
• Follow a Consistent Project Structure:
  src/test/java
      ├── base
      │   ├── BaseTest.java
      ├── pages
      │   ├── LoginPage.java
      ├── tests
      │   ├── LoginTest.java
      ├── utils
      │   ├── TestUtil.java

How does the Page Object Model improve maintainability?

Using the Project Object Model improves maintainability by providing a structured way to manage test scripts. It centralizes element locators, reducing redundancy and making updates easier when UI changes occur.

How does using POM reduce code duplication?

• POM centralizes all web elements and associated actions within dedicated classes, preventing redundant code across multiple test cases.
  
• Any change in the UI will just need to update the page object instead of modifying multiple test scripts, reducing maintenance efforts.
  
• By using these classes, automation scripts become modular, improving overall efficiency.

What makes code more readable with POM?

• POM organizes code in a structured manner by separating UI elements from test logic, making test scripts more understandable.
  
• Methods in page classes should have meaningful names to clearly describe actions, improving clarity.
  
• Test scripts are more concise, as they only call page object methods instead of handling element interactions directly.

Differences between Page Object Model and Page Factory

Common challenges while using Page Object Model and Page Factory

Some of the common difficulties while implementing the Page Object Model are:

• Adding too many methods or unnecessary logic can make maintenance difficult.
• Using static locators instead of dynamic ones can give test failures when UI changes.
• Not using explicit waits properly can cause synchronization issues.
• Poor structuring of page objects can lead to difficulty in maintaining large test cases.

How do you handle Dynamic Elements with Page Factory?

• Use WebDriverWait to ensure elements are ready before interaction.
• Use AjaxElementLocatorFactory to handle lazy loading elements efficiently.
• Use dynamic locators like XPath or CSS selectors to handle changing elements.
• Use JavaScriptExecutor for cases where elements load asynchronously.

Best Practices for Using Page Object Model

• Each class should represent a single page or component to improve maintainability.
• Tests should call methods from page objects without embedding test logic within them.
• Use an Object Repository to maintain locators in a structured way to make updates easier.
• Properly implement base classes and reusable interfaces to enhance scalability.

Which approach is best for Test Automation?

Choosing between the Page Object Model (POM) design pattern and the Page Factory framework depends on the project’s complexity, scalability requirements, and team expertise. POM is ideal for projects that require greater flexibility and control over elements and interactions, making it a better fit for large-scale automation frameworks. However, additional effort is required for element initialization and explicit wait handling.

Page Factory simplifies object management with automatic element initialization and built-in lazy loading, making it suitable for projects where ease of implementation and reduced duplicated code are priorities. In many cases, a mixed approach, combining POM for structuring and Page Factory for efficient element handling, can be the most effective strategy for building a scalable and maintainable Selenium automation framework.

Conclusion

Both the design patterns, Page Object Model and Page Factory, improve the structure, maintainability, and reusability of Selenium test automation scripts. Selecting the right approach depends on the project requirements, but both help reduce code duplication, improve readability, and make tests easier to manage.

Frequently Asked Questions and Answers

1. Is the Page Object Model only applicable to Selenium?

No, POM is used mostly in Selenium, but it is a general design pattern that can be applied to other UI automation tools like Cypress, Appium, and WebDriverIO.

2. Does Page Factory replace the need for explicit waits in Selenium?

No, while Page Factory provides lazy initialization, explicit waits (WebDriverWait) should still be used for better synchronization when dealing with dynamic elements.

3. What type of applications benefit the most from the Page Object Model?

Large-scale applications that need regular changes in their UI components benefit the most from POM, as it makes it easier to maintain and update test scripts.

4. What are the limitations of using Page Factory in Selenium?

Some of the common limitations of using Page Factory in Selenium are that it provides less flexibility for complex element interactions, requires annotations for every element, and may not be ideal for advanced test scenarios.

5. How does POM contribute to reducing test maintenance efforts?

By fixing UI locators and actions in separate classes, POM reduces the need to update multiple test scripts when UI changes occur.