What is a Policy Model (PM)?

Policy Model (PM) in the context of automated testing is an extension of the Page Object Model (POM). The main idea is to separate policies or business rules for interacting with page elements (and behaviors related to these policies) from the page objects themselves.

Instead of including checks and complex logic directly in Page Objects, these rules are moved to separate classes or modules — Policy Objects.

Advantages of this approach:

• Improved readability: Test scenarios become simpler and easier to understand, as they focus on the described action rather than its validation.
• Reusability: Policies can be used across different Page Objects or in various test scenarios.
• Separation of responsibilities: Page Objects are responsible only for interacting with page elements, while Policy Objects handle rules and validation.
• Simplified maintenance: Changing a business rule requires modifying only the Policy Object, not all Page Objects where the rule is applied.
• Better scalability: Easier to manage a large number of tests and pages as the application develops.

The structure of PM can look like this:

• Page Objects: Represent individual pages or UI modules. Contain element locators and methods for interacting with them (e.g., click_button(), enter_text()). They do not contain validation logic.
• Policy Objects: Represent business rules or policies. Contain methods for checking UI state or performing actions based on business logic (e.g., is_user_logged_in(), can_submit_form(), perform_checkout()). They can use one or multiple Page Objects.
• Tests: Use Policy Objects to execute scenarios that include checks and business logic.

Example (pseudo-code):

# Page Object
class LoginPage:
    def enter_username(self, username):
        # interact with username field
        pass

    def enter_password(self, password):
        # interact with password field
        pass

    def click_login_button(self):
        # interact with login button
        pass

# Policy Object
class AuthPolicy:
    def __init__(self, driver):
        self.login_page = LoginPage(driver)
        self.dashboard_page = DashboardPage(driver) # Assuming DashboardPage exists

    def login_as_user(self, username, password):
        self.login_page.enter_username(username)
        self.login_page.enter_password(password)
        self.login_page.click_login_button()
        # Potentially add checks here or in separate methods
        # return self.is_user_logged_in()

    def is_user_logged_in(self):
        # Check if dashboard elements are visible
        return self.dashboard_page.is_dashboard_displayed()

# Test
class LoginTest:
    def test_successful_login(self, driver):
        auth_policy = AuthPolicy(driver)
        auth_policy.login_as_user("test_user", "password123")
        assert auth_policy.is_user_logged_in(), "User should be logged in"