POM设计模式详解：构建可维护的UI自动化测试框架

1. 项目概述：为什么我们需要POM？

如果你做过UI自动化测试，尤其是项目稍微复杂一点，或者团队里不止一个人在写脚本，那你大概率经历过这样的场景：今天前端同事把登录按钮的ID从loginBtn改成了submitBtn，你吭哧吭哧写了上百行的测试脚本，结果一跑，全线飘红。你不得不打开十几个脚本文件，用查找替换功能，祈祷着别改错了地方。又或者，同一个页面的元素，被不同的人在不同的脚本里定位了无数次，代码里充斥着重复的driver.find_element(By.ID, "username")，维护起来简直是一场噩梦。

这就是我们今天要聊的POM（Page Object Model，页面对象模型）设计模式要解决的问题。它不是什么高深莫测的新技术，而是一种组织UI自动化测试代码的“最佳实践”或“设计模式”。简单来说，POM的核心思想是把测试脚本和页面元素、页面操作分离开。脚本只关心“要测什么业务逻辑”，而“怎么操作页面”这件事，被封装到了一个个独立的“页面对象”类里。

想象一下，你把每个网页（或网页上的一个功能模块）看作一个独立的“对象”。这个对象知道自己的所有“零件”（输入框、按钮、下拉菜单等），也知道自己能做哪些“动作”（输入、点击、选择等）。当测试脚本需要在这个页面上做点什么时，它不需要知道按钮的ID是什么，只需要对这个页面对象说：“嘿，登录页面，帮我用‘admin’这个用户名和‘123456’这个密码登录一下。”至于登录页面内部是怎么找到用户名输入框、密码输入框和登录按钮的，那是页面对象自己的事。

这样做的好处是显而易见的。当页面元素发生变化时，你只需要去修改对应的那个页面对象类，所有引用这个类的测试脚本就自动获得了更新，维护成本直线下降。代码的复用性、可读性也大大提升。所以，无论你是用Python的Selenium、Java的Selenium，还是Cypress、Playwright，理解和应用POM都是写出健壮、易维护的UI自动化测试代码的必经之路。

2. POM设计模式的核心思想与架构拆解

2.1 从“面条式代码”到“模块化设计”的演进

在深入POM的细节之前，我们先看看没有POM的代码长什么样，我称之为“面条式代码”。这种代码里，业务逻辑、元素定位、数据断言全部搅和在一起。

# 反面教材：没有POM的“面条式”测试脚本 def test_login(): driver = webdriver.Chrome() driver.get("http://example.com/login") # 定位元素和操作混杂 driver.find_element(By.ID, "username").send_keys("admin") driver.find_element(By.ID, "password").send_keys("123456") driver.find_element(By.ID, "loginBtn").click() # 断言也直接写在流程里 welcome_text = driver.find_element(By.CLASS_NAME, "welcome").text assert "admin" in welcome_text driver.quit()

这段代码的问题在于，它把“做什么”（登录）和“怎么做”（通过ID定位元素）紧密耦合了。一旦页面元素属性变更，你必须修改所有包含这些定位器的脚本，极易出错且效率低下。

POM模式则倡导一种清晰的分层架构，通常包含以下几层：

1. 基础层（Base Layer）：封装对WebDriver的最基本操作，比如初始化驱动、通用的等待、截图等。它作为所有页面对象的父类，提供公共能力。
2. 页面对象层（Page Object Layer）：这是POM的核心。每个页面（或页面组件）对应一个类。这个类包含两部分：
   • 元素定位器（Locators）：以类变量的形式，集中定义该页面所有需要操作的元素定位方式和表达式（如ID、XPath、CSS Selector）。
   • 页面操作（Actions/Methods）：定义一系列方法，每个方法代表一个用户可在该页面上执行的操作，如input_username(text)、click_login()。这些方法内部使用定义好的定位器来与元素交互。
3. 测试用例层（Test Case Layer）：这是真正的测试脚本。它只包含测试逻辑，例如“给定一个有效用户，当执行登录操作，那么应该跳转到主页”。它通过调用页面对象层提供的方法来驱动UI，并进行结果断言。
4. 数据层（可选，Data Layer）：将测试数据（如用户名、密码）从测试用例和页面对象中分离出来，可以通过文件（Excel、JSON、YAML）或数据库管理。

这种架构下，各层职责分明，就像搭建积木。测试用例是搭积木的人，页面对象是各种形状的积木块，基础层是积木的底座。搭积木的人不需要关心积木块内部是怎么生产的，只需要知道怎么用它来构建想要的形状。

2.2 POM的核心原则与优势分析

理解了架构，我们再来明确POM必须遵循的几个核心原则，这也是它优势的来源：

• 单一职责原则（Single Responsibility Principle）：一个页面对象类只负责一个页面（或组件）的元素和操作。登录页的修改不会影响到商品详情页的代码。
• 封装与隐藏细节：将复杂的元素定位逻辑封装在页面对象内部。测试脚本作者无需关心元素是用XPath还是CSS定位的，他们只需要调用像login_page.login(“user”, “pass”)这样语义清晰的方法。
• 高内聚，低耦合：与页面相关的所有操作都内聚在同一个类中。测试脚本与页面实现细节（HTML结构）解耦，仅通过公开的方法接口进行交互。
• 极大的可维护性：这是POM最大的卖点。页面UI变动时，修改点被隔离在少数几个页面对象类中，而不是散落在成千上万的测试脚本里。
• 提升可读性与协作效率：测试用例读起来像自然语言描述的验收标准，非常利于产品、开发和测试之间的沟通。新成员也能快速理解测试在做什么。

注意：POM是一种设计模式，而不是一个框架。你可以基于Selenium、Playwright等任何UI自动化工具来实现它。它的价值在于思想，而非某个具体的代码库。

3. 手把手实现一个基础的POM框架

理论说再多不如动手实践。下面我将以Python + Selenium为例，带你从零搭建一个最基础的POM框架。我们会创建一个简单的登录场景测试。

3.1 项目结构与环境准备

首先，规划好你的项目目录结构。清晰的目录是良好架构的开始。我推荐的结构如下：

your_automation_project/ │ ├── base/ # 基础层 │ └── base_page.py # 基础页面类 │ ├── pages/ # 页面对象层 │ ├── __init__.py │ ├── login_page.py # 登录页面对象 │ └── home_page.py # 主页页面对象 │ ├── tests/ # 测试用例层 │ ├── __init__.py │ └── test_login.py # 登录测试用例 │ ├── utilities/ # 工具层（可选） │ ├── __init__.py │ └── config_reader.py # 配置文件读取 │ ├── test_data/ # 数据层（可选） │ └── users.json │ ├── reports/ # 测试报告目录 ├── logs/ # 日志目录 └── requirements.txt # Python依赖列表

安装核心依赖。在requirements.txt中至少需要：

selenium>=4.0 pytest>=7.0 # 推荐使用pytest作为测试运行器 webdriver-manager # 自动管理浏览器驱动，非常方便

然后通过pip install -r requirements.txt安装。

3.2 构建基础页面类（BasePage）

BasePage是所有页面对象的父类，它封装了WebDriver的常用操作，避免在每个页面对象中重复编写。这是实现代码复用的关键一步。

# base/base_page.py from selenium.webdriver.support.ui import WebDriverWait from selenium.webdriver.support import expected_conditions as EC from selenium.common.exceptions import TimeoutException import logging class BasePage: """所有页面对象的基类""" def __init__(self, driver): self.driver = driver self.logger = logging.getLogger(__name__) # 可以设置一个全局的显式等待超时时间 self.wait = WebDriverWait(self.driver, timeout=10) def find_element(self, by, locator): """查找单个元素，并加入显式等待和日志""" try: self.logger.info(f"正在查找元素: {by} -> {locator}") element = self.wait.until(EC.presence_of_element_located((by, locator))) self.logger.info(f"元素查找成功: {by} -> {locator}") return element except TimeoutException: self.logger.error(f"元素查找超时: {by} -> {locator}") # 这里可以附加截图操作，便于调试 self.take_screenshot(f"element_not_found_{locator}") raise def click(self, by, locator): """点击元素""" element = self.find_element(by, locator) element.click() self.logger.info(f"已点击元素: {by} -> {locator}") def input_text(self, by, locator, text): """向输入框输入文本""" element = self.find_element(by, locator) element.clear() element.send_keys(text) self.logger.info(f"已在元素 [{by} -> {locator}] 中输入文本: {text}") def get_text(self, by, locator): """获取元素的文本内容""" element = self.find_element(by, locator) text = element.text self.logger.info(f"获取到元素 [{by} -> {locator}] 的文本: {text}") return text def take_screenshot(self, filename): """截图并保存""" screenshot_path = f"./screenshots/{filename}.png" self.driver.save_screenshot(screenshot_path) self.logger.info(f"截图已保存至: {screenshot_path}") # 可以根据需要添加更多通用方法，如：切换窗口/iframe、执行JS、获取属性等

实操心得：在BasePage中统一加入日志记录和异常处理至关重要。当测试失败时，详细的日志和自动截屏能帮你快速定位问题是出在元素定位上，还是业务流程上。webdriver-manager的引入让你无需手动下载和配置浏览器驱动，特别适合团队协作和CI/CD环境。

3.3 创建页面对象类（以LoginPage为例）

接下来，我们创建具体的页面对象。以登录页面为例，我们先分析页面元素，然后将它们封装起来。

# pages/login_page.py from selenium.webdriver.common.by import By from base.base_page import BasePage class LoginPage(BasePage): """登录页面对象""" # 1. 定位器（Locators） - 集中管理所有元素定位方式 # 使用元组 (By.策略, ‘定位表达式’) 是一种清晰的方式 USERNAME_INPUT = (By.ID, ‘username‘) # 假设登录页用户名的ID是‘username‘ PASSWORD_INPUT = (By.ID, ‘password‘) LOGIN_BUTTON = (By.ID, ‘loginBtn‘) ERROR_MESSAGE = (By.CLASS_NAME, ‘error-message‘) REMEMBER_ME_CHECKBOX = (By.NAME, ‘rememberMe‘) # 2. 页面操作（Actions） - 每个方法代表一个用户操作 def __init__(self, driver): super().__init__(driver) # 初始化父类BasePage # 可以在这里添加页面特有的初始化，比如访问登录页URL self.driver.get("http://your-app.com/login") self.logger.info("导航至登录页面") def enter_username(self, username): """输入用户名""" self.input_text(*self.USERNAME_INPUT, username) # 使用*解包元组 return self # 返回自身，支持链式调用 def enter_password(self, password): """输入密码""" self.input_text(*self.PASSWORD_INPUT, password) return self def click_login(self): """点击登录按钮""" self.click(*self.LOGIN_BUTTON) # 点击后页面会跳转，通常返回下一个页面的对象，这里先返回None # 实际项目中，可能 return HomePage(self.driver) return None def login(self, username, password): """完整的登录流程（业务组合操作）""" self.logger.info(f"执行登录操作，用户: {username}") self.enter_username(username) self.enter_password(password) return self.click_login() def get_error_message(self): """获取登录错误提示信息""" return self.get_text(*self.ERROR_MESSAGE) def is_remember_me_checked(self): """判断‘记住我‘复选框是否被选中""" element = self.find_element(*self.REMEMBER_ME_CHECKBOX) return element.is_selected() def check_remember_me(self): """勾选‘记住我‘""" if not self.is_remember_me_checked(): self.click(*self.REMEMBER_ME_CHECKBOX) return self

关键点解析：

• 定位器管理：将所有定位器定义为类变量，并放在文件顶部。这样，任何元素变更只需修改此处，一目了然。使用(By.策略, ‘表达式‘)的元组形式是常见且推荐的做法。
• 操作封装：每个方法都对应一个具体的用户交互。像login(username, password)这样的组合方法非常有用，它封装了最常见的业务流程，让测试用例更简洁。
• 链式调用：许多方法返回self（页面对象自身），这允许你写出像page.enter_username(‘admin‘).enter_password(‘123‘).click_login()这样流畅的代码，可读性更强。
• 页面跳转处理：click_login()方法之后，通常会跳转到主页。一个更高级的实现是让这个方法返回HomePage的对象，这样测试用例可以无缝衔接。例如：home_page = login_page.login(…)。

3.4 编写测试用例

有了封装好的页面对象，编写测试用例就变得异常清晰和简单。我们使用pytest来编写。

# tests/test_login.py import pytest from selenium import webdriver from selenium.webdriver.chrome.service import Service from webdriver_manager.chrome import ChromeDriverManager from pages.login_page import LoginPage from pages.home_page import HomePage # 假设我们有主页对象 import logging # 配置日志 logging.basicConfig(level=logging.INFO) @pytest.fixture(scope="function") def driver(): """pytest fixture: 为每个测试函数提供独立的driver实例""" # 使用webdriver-manager自动管理Chrome驱动 service = Service(ChromeDriverManager().install()) options = webdriver.ChromeOptions() options.add_argument(‘--headless‘) # 无头模式，适合CI环境 options.add_argument(‘--no-sandbox‘) options.add_argument(‘--disable-dev-shm-usage‘) driver = webdriver.Chrome(service=service, options=options) driver.implicitly_wait(5) # 设置隐式等待（备用） driver.maximize_window() yield driver # 测试结束后清理 driver.quit() class TestLogin: """登录功能测试类""" def test_login_success(self, driver): """测试正常登录成功""" # 1. 初始化登录页面对象 login_page = LoginPage(driver) # 2. 执行登录操作（调用页面对象封装的方法） # 这里login方法返回None，实际可返回HomePage login_page.login(‘valid_user‘, ‘valid_password‘) # 3. 初始化主页对象，并进行断言 home_page = HomePage(driver) welcome_text = home_page.get_welcome_message() # 4. 断言：验证登录成功后的状态 assert ‘valid_user‘ in welcome_text assert home_page.is_logout_button_displayed() logging.info(“测试通过：有效用户登录成功”) def test_login_failure_with_wrong_password(self, driver): """测试密码错误登录失败""" login_page = LoginPage(driver) # 使用链式调用，清晰表达操作序列 login_page.enter_username(‘valid_user‘) \ .enter_password(‘wrong_password‘) \ .click_login() # 断言：验证出现了正确的错误提示 error_msg = login_page.get_error_message() expected_msg = ‘密码错误‘ # 根据实际应用提示修改 assert error_msg == expected_msg logging.info(“测试通过：密码错误时提示信息正确”) @pytest.mark.parametrize(“username, password, expected_error“, [ (““, “somepass“, “用户名不能为空“), (“admin“, ““, “密码不能为空“), (“invalid“, “invalid“, “用户名或密码错误“), ]) def test_login_failure_with_various_inputs(self, driver, username, password, expected_error): """参数化测试：多种错误输入场景""" login_page = LoginPage(driver) login_page.login(username, password) assert login_page.get_error_message() == expected_error

测试用例设计要点：

• Fixture的使用：pytest的fixture（如driver）用于管理测试前置（初始化）和后置（清理）条件，让测试函数本身只关注业务逻辑。
• 清晰的三段式结构：准备（Arrange）- 初始化页面对象；执行（Act）- 调用页面对象方法；断言（Assert）- 验证结果。这是单元测试的经典模式。
• 参数化测试：使用@pytest.mark.parametrize可以轻松地用多组数据运行同一个测试逻辑，极大提高了测试覆盖率，减少了代码重复。
• 断言明确：断言应该验证业务结果，而不是实现细节。例如，断言“欢迎信息包含用户名”，而不是断言“某个特定的HTML元素存在”。

运行测试只需在项目根目录下执行命令：pytest tests/test_login.py -v。-v参数可以输出更详细的结果。

4. 进阶实践：让POM框架更健壮和易用

基础POM搭建完成后，我们可以引入更多工程化实践来提升框架的健壮性、可维护性和可配置性。

4.1 使用Page Factory模式优化元素定位

Selenium提供了一个PageFactory类（在Java中很常见，Python中可以通过selenium.webdriver.support.PageFactory或第三方库如page-objects实现其思想），它支持使用注解（Java）或装饰器（Python）来声明元素，并可以在运行时自动初始化（init_elements）。这能让页面对象的代码更简洁。

在Python中，我们通常借鉴其“延迟查找”的思想。一种常见的做法是使用属性描述符（property）或__getattr__魔法方法，实现元素的懒加载（用时才查找），而不是在__init__中一次性查找所有元素。不过，对于大多数项目，前面展示的显式定位器元组方式已经足够清晰和高效。过度设计有时反而会增加复杂度。

4.2 组件化与复杂页面的处理

现代Web应用大量使用可复用的组件，比如导航栏、侧边菜单、模态框、消息通知等。如果每个用到这些组件的页面都重新定义一遍相关元素和操作，就又产生了重复。

解决方案是组件化。将通用组件也抽象成独立的类。

# pages/components/navbar_component.py from base.base_page import BasePage from selenium.webdriver.common.by import By class NavBarComponent(BasePage): """导航栏组件""" USER_AVATAR = (By.CLASS_NAME, ‘user-avatar‘) LOGOUT_LINK = (By.LINK_TEXT, ‘退出登录‘) NOTIFICATION_BELL = (By.ID, ‘notifications‘) def __init__(self, driver): super().__init__(driver) # 组件可能没有独立的URL，它依附于某个页面 def click_user_avatar(self): self.click(*self.USER_AVATAR) return self def click_logout(self): self.click(*self.LOGOUT_LINK) from pages.login_page import LoginPage # 避免循环导入 return LoginPage(self.driver) # 退出后返回登录页 def get_notification_count(self): bell = self.find_element(*self.NOTIFICATION_BELL) # 假设数字显示在一个子span里 count_span = bell.find_element(By.TAG_NAME, ‘span‘) return int(count_span.text)

然后，在需要使用导航栏的页面类中，不是继承，而是组合这个组件。

# pages/home_page.py from base.base_page import BasePage from pages.components.navbar_component import NavBarComponent class HomePage(BasePage): WELCOME_MSG = (By.ID, ‘welcome‘) def __init__(self, driver): super().__init__(driver) self.navbar = NavBarComponent(driver) # 组合导航栏组件 def get_welcome_message(self): return self.get_text(*self.WELCOME_MSG) # 现在，HomePage的对象可以直接使用navbar的方法 # 例如：home_page.navbar.click_logout()

这样，组件逻辑被完美复用，任何包含导航栏的页面只需“拥有”一个组件实例即可。

4.3 集成数据驱动与配置文件

将测试数据（如用户名、密码、URL）和配置（如浏览器类型、超时时间）从代码中分离出来，是提升框架灵活性的关键。

1. 配置文件（如config.ini或config.yaml）：

# config.yaml browser: chrome headless: true base_url: ‘http://your-app.com‘ timeout: 10 credentials: valid_username: ‘test_user‘ valid_password: ‘Test@123‘

2. 数据文件（如test_data/login_data.json）：

[ { “test_case“: “valid_login“, “username“: “test_user“, “password“: “Test@123“, “expected“: “login_success“ }, { “test_case“: “invalid_password“, “username“: “test_user“, “password“: “wrong“, “expected“: “error_password“ } ]

3. 在框架中读取：创建一个工具类来读取这些配置和数据，并在BasePage或测试的fixture中使用。

# utilities/config_reader.py import yaml import json import os class ConfigReader: _config = None @classmethod def get_config(cls): if cls._config is None: config_path = os.path.join(os.path.dirname(__file__), ‘..‘, ‘config.yaml‘) with open(config_path, ‘r‘, encoding=‘utf-8‘) as f: cls._config = yaml.safe_load(f) return cls._config @classmethod def get_test_data(cls, data_file): data_path = os.path.join(os.path.dirname(__file__), ‘..‘, ‘test_data‘, data_file) with open(data_path, ‘r‘, encoding=‘utf-8‘) as f: return json.load(f) # 在base_page.py中使用 from utilities.config_reader import ConfigReader class BasePage: def __init__(self, driver): self.driver = driver self.config = ConfigReader.get_config() self.base_url = self.config[‘base_url‘] self.timeout = self.config[‘timeout‘] self.wait = WebDriverWait(self.driver, self.timeout)

4. 更新测试用例为数据驱动：

# tests/test_login_data_driven.py import pytest from utilities.config_reader import ConfigReader class TestLoginDataDriven: @pytest.fixture def login_data(self): return ConfigReader.get_test_data(‘login_data.json‘) @pytest.mark.parametrize(“data“, login_data()) def test_login_with_data(self, driver, data): login_page = LoginPage(driver) login_page.login(data[‘username‘], data[‘password‘]) if data[‘expected‘] == ‘login_success‘: home_page = HomePage(driver) assert data[‘username‘] in home_page.get_welcome_message() elif data[‘expected‘] == ‘error_password‘: assert ‘密码错误‘ in login_page.get_error_message() # ... 其他预期结果判断

通过数据驱动，你可以轻松地通过修改外部数据文件来增加、删除或修改测试场景，而无需触碰核心测试代码。

4.4 日志、报告与失败截图

一个专业的自动化框架必须有完善的日志和报告系统。

• 日志：使用Python内置的logging模块，为不同级别（DEBUG, INFO, WARNING, ERROR）配置格式和输出（控制台、文件）。在BasePage和关键操作中加入日志记录。
• 报告：pytest可以集成丰富的报告插件，如pytest-html生成美观的HTML报告，allure-pytest生成功能强大的Allure报告。
  • 安装：pip install pytest-html allure-pytest
  • 运行：pytest tests/ --html=reports/report.html --self-contained-html
  • 运行：pytest tests/ --alluredir=./allure-results，然后使用allure serve ./allure-results查看。
• 失败自动截图：这应该在BasePage的异常处理中完成（如前文take_screenshot方法）。更优雅的方式是使用pytest的钩子函数（hook），在测试失败时自动调用截图。

# 在conftest.py文件中（pytest会自动发现） import pytest from datetime import datetime @pytest.hookimpl(hookwrapper=True) def pytest_runtest_makereport(item, call): """Hook函数，用于在测试失败时截图""" outcome = yield report = outcome.get_result() if report.when == “call“ and report.failed: # 假设测试用例的driver fixture名字是‘driver‘ driver_fixture = item.funcargs.get(‘driver‘) if driver_fixture: timestamp = datetime.now().strftime(“%Y%m%d_%H%M%S“) screenshot_name = f“{item.name}_{timestamp}.png“ screenshot_path = f“./reports/screenshots/{screenshot_name}“ driver_fixture.save_screenshot(screenshot_path) # 可以将截图路径附加到HTML报告中 if hasattr(report, ‘extra‘): from pytest_html import extras report.extra.append(extras.image(screenshot_path))

5. 常见问题、陷阱与最佳实践实录

在实际项目中应用POM，你会遇到各种坑。下面是我总结的一些典型问题和解决方案。

5.1 元素定位的稳定性与“最佳实践”

元素定位是UI自动化的基石，也是最容易出问题的地方。

问题1：元素定位器太脆弱，经常因为前端微调而失效。

• 避坑指南：
  1. 优先级：ID > Name > CSS Selector > XPath。能不用XPath尽量不用，尤其是包含索引（如div[3]）或完整路径（如/html/body/div[1]/form/input）的绝对XPath，它们极其脆弱。
  2. 相对XPath与CSS选择器：如果必须用，使用基于属性、文本或关系的相对定位。例如：//button[text()=‘提交‘]或input[type=‘email‘]。
  3. 自定义属性：与开发团队协商，为重要的测试元素添加唯一的、不会随样式改变的属性，如>class PageWithIframe(BasePage): IFRAME = (By.ID, ‘myIframe‘) INNER_BUTTON = (By.ID, ‘innerBtn‘) def click_inner_button(self): # 1. 切换到iframe self.driver.switch_to.frame(self.find_element(*self.IFRAME)) # 2. 操作iframe内的元素 self.click(*self.INNER_BUTTON) # 3. 操作完成后，切回主文档 self.driver.switch_to.default_content()切记：操作完成后一定要切回默认上下文，否则后续查找元素会失败。

问题3：点击链接或按钮后打开了新窗口/标签页。

• 解决方案：在点击可能打开新窗口的元素前，记录当前窗口句柄。点击后，切换到新窗口，操作完毕后再切回。

  def click_and_switch_to_new_window(self, by, locator): current_window = self.driver.current_window_handle self.click(by, locator) # 等待新窗口出现 self.wait.until(EC.number_of_windows_to_be(2)) # 切换到新窗口 for window_handle in self.driver.window_handles: if window_handle != current_window: self.driver.switch_to.window(window_handle) break return self # 或者返回新窗口对应的页面对象

5.4 测试数据的管理与隔离

问题：测试数据相互干扰，比如一个测试创建的数据影响了另一个测试。

• 最佳实践：
  1. 每个测试独立：使用pytest的fixture，确保每个测试函数都有全新的浏览器实例和会话（scope=“function“）。对于需要登录的测试，可以在fixture中完成登录并返回已登录的页面对象，测试结束后自动清理（如退出登录）。
  2. 数据库隔离：如果测试涉及后端数据，最好在测试开始前通过API或直接操作数据库来准备测试数据（setup），在测试结束后清理（teardown）。可以使用pytest的@pytest.fixture配合yield来实现。
  3. 使用测试账号：为自动化测试准备专用的测试账号和测试数据，并与真实用户数据隔离。

5.5 框架的维护与团队协作

问题：随着项目扩大，页面对象类越来越多，如何维护？

• 最佳实践：
  1. 统一的命名与编码规范：团队内统一页面类、方法、定位器的命名风格（如LoginPage、enter_username、USERNAME_INPUT）。
  2. 定期重构：当发现多个页面有相似操作时，考虑提取公共方法到BasePage或创建Mixin类。当一个页面对象类过于庞大时，考虑按功能模块将其拆分成多个小类。
  3. 文档与注释：为复杂的业务方法或特殊的定位逻辑添加注释。可以考虑使用类型提示（Type Hints）来提高代码的可读性和IDE的支持。
  4. 代码审查：将页面对象和测试用例的代码纳入团队的代码审查流程，确保代码质量和风格统一。

UI自动化测试，尤其是基于POM的设计，是一个需要持续投入和优化的工程。它初期搭建需要一些成本，但带来的长期维护收益和团队效率提升是巨大的。记住，目标是让测试代码像产品代码一样清晰、健壮和可维护。当你发现修改一个元素定位只需要改一个地方，当你看到新同事能很快写出清晰的测试用例时，你就会觉得这一切的投入都是值得的。