1. 项目概述：为什么我们需要PO模式？

如果你写过UI自动化测试脚本，尤其是用Selenium这类工具，大概率经历过这样的场景：一个登录页面的定位器变了，你不得不翻遍几十个、上百个测试用例文件，把里面所有关于“用户名输入框”、“密码输入框”、“登录按钮”的定位代码挨个改一遍。改到一半，你可能会想，有没有一种方法，能让页面元素的变动只在一个地方修改就搞定？这就是PO（Page Object，页面对象）模式要解决的核心痛点。

PO模式不是什么高深莫测的黑科技，它本质上是一种设计思想，一种代码组织方式。它的核心目标就一个：将测试脚本（业务逻辑）与页面元素（定位与操作）分离。听起来很简单，但做得好与不好，直接决定了你的自动化测试框架是“一次性玩具”还是“可维护的资产”。我见过太多团队一开始为了赶进度，直接录制脚本或者写一堆线性代码，后期维护成本指数级上升，最终导致自动化项目失败。PO模式，就是避免这种悲剧的第一道，也是最重要的一道防线。

简单来说，PO模式让你为每个网页（或页面区域）创建一个对应的“类”（Class）。这个类里不关心具体的测试流程（比如先登录再下单），它只做两件事：1. 定义这个页面上有哪些元素（比如按钮、输入框）；2. 封装对这些元素的基本操作（比如输入文本、点击）。而你的测试用例，则变成了一系列清晰可读的业务步骤，通过调用这些页面对象的方法来完成。当页面UI改动时，你只需要去修改对应的那个页面对象类，所有引用该类的测试用例都能自动生效，维护效率的提升是颠覆性的。

2. PO模式的核心架构与三层设计解析

网上很多文章会提到“PO三层模式”，这其实是一个在实践中被广泛验证的最佳实践结构。它不是什么强制规范，但遵循这个结构能让你少走很多弯路。这三层分别是：BasePage层（基础页面层）、PageObject层（页面对象层）、TestCase层（测试用例层）。它们各司其职，共同构建了一个稳定、可扩展的自动化框架。

2.1 第一层：BasePage层——框架的基石

BasePage层，也叫基础页面层，这是整个PO框架中最核心、最体现设计功底的一层。它的定位是：封装所有页面对象的共性操作，并提供统一的、健壮的基础能力。你可以把它想象成汽车的方向盘、油门和刹车，无论你开的是轿车还是SUV，这些基础操控逻辑都是一样的。

BasePage层具体做什么？

1. 二次封装Selenium原生API：Selenium提供的find_element、click、send_keys等方法很基础，但不够“智能”和“健壮”。BasePage会对它们进行包装。例如，在click方法中加入显式等待，确保元素可点击再操作；在send_keys方法前先执行clear，避免残留文本影响。
2. 提供公共组件方法：比如处理网页弹窗（alert）、切换窗口/iframe、执行JavaScript脚本、截图并附加到测试报告、等待页面加载完成等。这些方法会被所有具体的页面对象调用。
3. 管理WebDriver实例：通常，BasePage的__init__方法会接收一个driver（WebDriver实例）并保存起来。这样，所有继承自BasePage的页面对象都能使用同一个driver进行页面操作，保证了会话的一致性。
4. 定义日志和异常处理规范：在关键操作前后加入日志记录，方便调试。定义统一的异常类型，比如ElementNotFoundError，让错误信息更清晰。

为什么必须要有这一层？没有BasePage，每个页面对象类（PageObject）都需要自己实现等待、日志、异常处理。这会导致大量重复代码，且一旦想改进某个基础逻辑（比如将隐式等待改为显式等待），就需要修改所有页面类，维护噩梦就此开始。BasePage层实现了“公共逻辑下沉”，是代码复用和架构统一的关键。

实操心得：在设计BasePage时，一个常见的争议是“封装粒度”。我个人的经验是，封装到“业务无感知”的程度即可。例如，一个input_text(locator, text)方法，内部封装了查找元素、等待可见、清空、输入、日志记录。测试用例编写者只需要关心“在哪个位置输入什么文本”，完全不用管底层是怎么实现的。这极大降低了用例编写的门槛和出错率。

2.2 第二层：PageObject层——页面的代言人

PageObject层是直接与具体网页或页面组件对应的类。每个重要的页面（如登录页、主页、商品详情页）或可复用的组件（如头部导航栏、侧边菜单）都可以是一个PageObject类。这个层是PO模式与具体业务UI的桥梁。

一个标准的PageObject类包含什么？

1. 元素定位器（Locators）：这是类的核心属性。使用清晰易懂的变量名来保存每个页面元素的定位方式和表达式。强烈建议使用元组（Tuple）或自定义的Locator类来存储，例如LOGIN_BUTTON = (By.ID, “submit”)。绝对避免在方法内部硬编码定位字符串。
2. 页面操作方法：这些方法代表用户在该页面上可以执行的操作。每个方法应尽量对应一个完整的、有意义的用户交互。例如，LoginPage类里应该有login(username, password)方法，而不是让用例分别调用input_username、input_password、click_login。
3. 页面断言方法（可选但推荐）：用于验证页面是否处于预期状态。例如，is_login_success()可以检查登录后是否跳转到了正确页面或出现了成功提示。这有助于将断言逻辑也从测试用例中剥离，让用例更专注于“流程”。

设计原则：高内聚、低耦合

• 高内聚：一个LoginPage类应该只包含和登录页面相关的元素和操作。不要把搜索框的操作也塞进来。
• 低耦合：PageObject类的方法不应该返回其他PageObject实例。页面跳转的逻辑应该由测试用例或一个专门的“流程类”来控制。比如，login方法执行后，返回HomePage实例是一种常见的错误做法，这会让页面对象之间产生依赖。正确做法是，login方法只负责执行登录动作，测试用例在调用login后，再初始化HomePage对象。

2.3 第三层：TestCase层——业务的导演

TestCase层，即我们的测试脚本。在这一层，PO模式的价值得到最大体现。测试用例不再是与HTML元素纠缠的“脚本”，而是读起来像自然语言或产品文档的“场景描述”。

一个使用PO模式的测试用例长什么样？

def test_user_login_success(self): # 1. 打开登录页面 login_page = LoginPage(self.driver) login_page.open() # open()方法可能定义在LoginPage中，内部调用driver.get(url) # 2. 执行登录操作 login_page.login(username="test_user", password="secure_pass123") # 3. 验证登录成功 home_page = HomePage(self.driver) assert home_page.is_user_logged_in() == True assert home_page.get_welcome_message() == "Welcome, test_user!"

你看，即使不懂代码的产品经理或测试新手，也能大致看懂这个用例在做什么：“打开登录页，用账号密码登录，然后检查主页的欢迎信息”。业务逻辑变得极其清晰。

这一层的核心职责：

1. 组织页面对象：按顺序初始化并使用不同的PageObject类。
2. 编排业务流：调用页面对象的方法，串联起完整的用户场景。
3. 进行业务断言：验证业务流程的结果是否符合预期（通常调用PageObject提供的断言方法或直接使用测试框架的assert）。
4. 处理测试数据和环境：管理测试用的账号、商品ID等数据。

3. 从零开始：手把手实现一个PO模式框架

理论讲完了，我们动手搭一个。假设我们要为一个简单的电商网站（包含登录、搜索、加购）设计自动化测试。我们将使用pytest作为测试运行器，因为它比unittest更简洁强大。

3.1 项目结构与环境搭建

首先，建立清晰的项目目录结构，这是良好架构的开始：

your_automation_project/ ├── base/ # 基础层 │ ├── __init__.py │ └── base_page.py # BasePage类 ├── pages/ # 页面对象层 │ ├── __init__.py │ ├── login_page.py │ ├── home_page.py │ └── product_page.py ├── tests/ # 测试用例层 │ ├── __init__.py │ ├── conftest.py # pytest夹具配置，如driver初始化 │ └── test_login.py ├── utilities/ # 工具类（可选） │ ├── __init__.py │ └── logger.py └── requirements.txt

在requirements.txt中写明依赖：

pytest>=7.0.0 selenium>=4.0.0 webdriver-manager>=3.0.0 # 自动管理浏览器驱动，强烈推荐 pytest-html>=3.0.0 # 生成HTML报告

3.2 实现BasePage基类

这是整个框架的“心脏”。我们创建一个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, NoSuchElementException import logging import time class BasePage: """所有页面对象的基类""" def __init__(self, driver, timeout=10): """ 初始化BasePage。 :param driver: WebDriver实例 :param timeout: 默认显式等待超时时间（秒） """ self.driver = driver self.timeout = timeout self.logger = logging.getLogger(__name__) # 可以在这里初始化一个全局的显式等待对象 self.wait = WebDriverWait(self.driver, self.timeout) def find_element(self, locator): """ 查找单个元素，加入显式等待和友好日志。 :param locator: 定位器元组，如 (By.ID, "username") :return: WebElement 对象 """ try: self.logger.info(f"正在查找元素: {locator}") # 等待元素出现在DOM中并且可见 element = self.wait.until( EC.visibility_of_element_located(locator) ) self.logger.info(f"元素查找成功: {locator}") return element except TimeoutException: self.logger.error(f"查找元素超时: {locator}") # 可以在这里进行截图，方便调试 self.take_screenshot("element_not_found") raise NoSuchElementException(f"元素未找到: {locator}") def click(self, locator): """点击元素，点击前确保元素可点击""" element = self.find_element(locator) try: self.logger.info(f"点击元素: {locator}") # 等待元素可点击 clickable_element = self.wait.until(EC.element_to_be_clickable(locator)) clickable_element.click() except Exception as e: self.logger.error(f"点击元素失败 {locator}: {e}") raise def input_text(self, locator, text): """在输入框输入文本，先清空原有内容""" element = self.find_element(locator) try: self.logger.info(f"向元素 {locator} 输入文本: {text}") element.clear() # 先清空 element.send_keys(text) except Exception as e: self.logger.error(f"输入文本失败 {locator}: {e}") raise def get_text(self, locator): """获取元素的文本内容""" element = self.find_element(locator) try: text = element.text self.logger.info(f"获取元素 {locator} 的文本: {text}") return text except Exception as e: self.logger.error(f"获取文本失败 {locator}: {e}") raise def take_screenshot(self, name): """截图并保存，文件名包含时间戳""" timestamp = time.strftime("%Y%m%d_%H%M%S") filename = f"screenshot_{name}_{timestamp}.png" # 这里可以定义你的截图保存路径，比如一个专门的screenshots文件夹 save_path = f"./screenshots/{filename}" self.driver.save_screenshot(save_path) self.logger.info(f"截图已保存至: {save_path}") return save_path # 还可以添加更多通用方法，如切换窗口、处理alert等

关键点解析：

• __init__中注入driver：这是PO模式的通用做法，保证所有页面操作在同一个浏览器会话中。
• 显式等待：在find_element中，我们使用WebDriverWait配合EC.visibility_of_element_located。这比隐式等待或time.sleep更可靠、更高效。它意味着“我最多等10秒，只要元素一出现且可见就立刻返回，否则报错”。
• 日志记录：每个关键步骤都记录日志，这在调试复杂用例时是救命稻草。通过日志级别（INFO, ERROR），可以灵活控制输出信息量。
• 异常处理与截图：当元素找不到或操作失败时，除了抛出异常，还自动截图。截图文件名包含时间戳和场景名，便于事后追溯。

3.3 实现具体的PageObject类

以登录页面pages/login_page.py为例：

from selenium.webdriver.common.by import By from base.base_page import BasePage class LoginPage(BasePage): """登录页面对象""" # 1. 定位器定义（核心） # 使用常量、清晰的变量名，定位策略和表达式分离 USERNAME_INPUT = (By.ID, "username") PASSWORD_INPUT = (By.NAME, "password") LOGIN_BUTTON = (By.XPATH, "//button[@type='submit']") ERROR_MESSAGE = (By.CLASS_NAME, "alert-error") SUCCESS_MESSAGE = (By.CSS_SELECTOR, ".welcome-msg") # 2. 页面URL（可选，如果页面有固定地址） URL = "https://www.example.com/login" def __init__(self, driver): super().__init__(driver) # 调用父类初始化 def open(self): """打开登录页面""" self.logger.info(f"打开登录页面: {self.URL}") self.driver.get(self.URL) # 可以添加一个等待，确保页面关键元素加载完成 self.find_element(self.USERNAME_INPUT) def login(self, username, password): """ 登录操作。这是一个完整的业务动作封装。 :param username: 用户名 :param password: 密码 """ self.logger.info(f"执行登录操作，用户名: {username}") self.input_text(self.USERNAME_INPUT, username) self.input_text(self.PASSWORD_INPUT, password) self.click(self.LOGIN_BUTTON) # 注意：这个方法不返回任何页面对象，跳转逻辑由测试用例控制 def get_error_message(self): """获取登录错误提示信息""" try: # 错误信息可能不会立即出现，稍作等待 time.sleep(1) # 对于动态加载的内容，可以用更智能的等待 return self.get_text(self.ERROR_MESSAGE) except NoSuchElementException: return None # 没有错误信息，可能登录成功 def is_login_success(self): """判断是否登录成功（通过检查成功元素是否存在）""" try: # 快速查找，不抛异常 element = self.driver.find_element(*self.SUCCESS_MESSAGE) return element.is_displayed() except NoSuchElementException: return False

设计要点：

1. 定位器集中管理：所有元素定位信息都在类开头以常量的形式定义。如果前端ID从username改成了userName，你只需要修改这一个地方。
2. 方法对应业务动作：login方法封装了“输入用户名-输入密码-点击登录”这一系列底层操作。测试用例只需调用login(username, password)，意图非常明确。
3. 不处理页面跳转：login方法执行后，浏览器可能跳转到首页或停留在登录页（如果失败）。该方法本身不返回新的页面对象。跳转后的断言和后续操作，由测试用例根据业务逻辑来决定。这保持了PageObject的纯洁性。

3.4 编写基于PO的测试用例

最后，在tests/test_login.py中编写用例。我们会使用pytest的fixture来管理driver的生命周期。

首先，在tests/conftest.py中定义全局夹具：

import pytest from selenium import webdriver from selenium.webdriver.chrome.service import Service from webdriver_manager.chrome import ChromeDriverManager @pytest.fixture(scope="function") # 每个测试函数执行一次 def driver(): """初始化WebDriver""" # 使用webdriver-manager自动下载和管理chromedriver 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对象提供给测试用例 driver.quit() # 测试结束后关闭浏览器

然后，编写测试用例：

import pytest from pages.login_page import LoginPage from pages.home_page import HomePage class TestLogin: def test_login_success(self, driver): """测试正常登录流程""" # 1. 初始化页面对象 login_page = LoginPage(driver) # 2. 执行业务流程 login_page.open() login_page.login(username="valid_user@example.com", password="CorrectPass!123") # 3. 验证结果 home_page = HomePage(driver) # 登录成功后，应进入首页 assert home_page.is_user_logged_in() is True welcome_text = home_page.get_welcome_message() assert "valid_user" in welcome_text def test_login_failure_wrong_password(self, driver): """测试密码错误登录失败""" login_page = LoginPage(driver) login_page.open() login_page.login(username="valid_user@example.com", password="WrongPass") # 验证停留在登录页，并出现错误提示 error_msg = login_page.get_error_message() assert error_msg is not None assert "密码错误" in error_msg or "Invalid" in error_msg # 可以进一步断言当前URL仍是登录页 assert "login" in driver.current_url

用例特点：

• 清晰：读起来像测试用例文档。
• 健壮：元素查找有等待，失败有截图和日志。
• 易维护：登录页UI改动，只需修改LoginPage类。

4. PO模式进阶技巧与最佳实践

实现基础三层结构只是开始，要让PO框架真正强大、易用，还需要一些进阶技巧。

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

如果你觉得每个元素都要写find_element有点繁琐，可以考虑使用Page Factory模式，它通过@property装饰器或描述符，让页面元素像类属性一样被访问。不过，在Python中，更常见的是一种轻量级实现：使用描述符或元类来自动化元素的查找。这里介绍一个利用__getattr__魔术方法的简洁实现：

在BasePage中添加：

class BasePage: # ... 之前的代码 ... def __getattr__(self, name): """ 动态查找元素。当访问一个不存在的属性时，尝试在 `self.locators` 字典中查找定位器。 需要在具体的PageObject类中定义 `locators` 字典。 例如：在LoginPage中，定义 self.locators = {‘username_input’: (By.ID, ‘username‘)} 那么，在测试中就可以用 page.username_input 来获取元素对象。 """ if hasattr(self, 'locators') and name in self.locators: locator = self.locators[name] return self.find_element(locator) raise AttributeError(f"‘{self.__class__.__name__}‘ object has no attribute ‘{name}‘")

然后在LoginPage中：

class LoginPage(BasePage): def __init__(self, driver): super().__init__(driver) # 将定位器定义在字典中 self.locators = { ‘username_input‘: (By.ID, "username"), ‘password_input‘: (By.NAME, "password"), ‘login_button‘: (By.XPATH, "//button[@type='submit']"), } def login(self, username, password): # 现在可以直接通过属性访问元素，代码更简洁 self.username_input.send_keys(username) # 自动触发 __getattr__ 查找并返回WebElement self.password_input.send_keys(password) self.login_button.click()

这种方法让页面对象的代码更加简洁，但会牺牲一些明确性（因为self.username_input看起来像一个WebElement对象，但实际上每次访问都会触发一次查找）。权衡点在于：如果你追求极致的代码简洁和类似PageFactory的写法，可以用；如果追求明确和可控，传统的显式find_element调用更稳妥。

4.2 组件化封装：处理复杂页面

现代Web应用有很多可复用的UI组件，比如模态框（Modal）、消息通知（Toast）、数据表格（DataGrid）。为这些组件创建独立的PageObject类，然后在主页面中组合它们，是保持代码清晰的关键。

例如，创建一个components/notification.py：

from base.base_page import BasePage from selenium.webdriver.common.by import By class NotificationComponent(BasePage): """通用通知消息组件""" MESSAGE = (By.CSS_SELECTOR, ".ant-notification-notice-message") CLOSE_BUTTON = (By.CSS_SELECTOR, ".ant-notification-notice-close") def get_message(self): """获取通知文本""" return self.get_text(self.MESSAGE) def close(self): """关闭通知""" self.click(self.CLOSE_BUTTON)

在主页面的PageObject中使用它：

class HomePage(BasePage): def __init__(self, driver): super().__init__(driver) self.notification = NotificationComponent(driver) # 组合组件 def do_something(self): # ... 某些操作会触发通知 ... msg = self.notification.get_message() assert "操作成功" in msg self.notification.close()

组件化的好处：逻辑隔离，复用性强。如果通知组件的样式变了，只需要修改NotificationComponent类。

4.3 数据驱动与PO模式的结合

测试数据（如用户名、密码、商品ID）不应该硬编码在测试用例或页面对象中。最佳实践是使用数据驱动测试（DDT）。pytest有一个强大的插件pytest.mark.parametrize。

import pytest # 将测试数据提取出来 test_login_data = [ ("valid_user", "correct_pw", True, "登录成功"), ("valid_user", "wrong_pw", False, "密码错误"), ("", "correct_pw", False, "用户名不能为空"), ] @pytest.mark.parametrize("username, password, expected_success, expected_msg_part", test_login_data) def test_login_with_data_driven(driver, username, password, expected_success, expected_msg_part): """数据驱动登录测试""" login_page = LoginPage(driver) login_page.open() login_page.login(username, password) if expected_success: home_page = HomePage(driver) assert home_page.is_user_logged_in() is True else: error_msg = login_page.get_error_message() assert error_msg is not None assert expected_msg_part in error_msg

这样，增加新的测试场景（如密码长度限制、特殊字符处理）只需要在test_login_data列表中添加一组数据即可，无需编写新的测试函数。页面对象LoginPage.login()方法保持不变，实现了数据与逻辑的分离。

4.4 等待策略的精细化设计

等待是UI自动化的核心难题。BasePage中我们用了显式等待，但这还不够。

1. 自定义等待条件：Selenium的expected_conditions可能不满足所有场景。例如，等待某个元素包含特定文本：

   from selenium.webdriver.support.expected_conditions import _element_if_visible def text_to_be_present_in_element(locator, text): """自定义等待条件：等待元素包含特定文本""" def _predicate(driver): try: element_text = _element_if_visible(driver.find_element(*locator)).text return text in element_text except Exception: return False return _predicate # 在页面对象中使用 def wait_for_welcome_message(self, expected_text): condition = text_to_be_present_in_element(self.WELCOME_MSG, expected_text) self.wait.until(condition)

2. 重试机制：对于某些不稳定的操作（如点击后页面刷新慢），可以在操作外围添加重试装饰器。
3. 彻底避免time.sleep：除非万不得已（如等待一个非JS控制的固定动画），否则永远使用显式等待。time.sleep是测试脚本不稳定和速度慢的罪魁祸首。

5. 常见问题、调试技巧与避坑指南

即使有了完美的PO框架，在实际编写和运行测试时，你依然会遇到各种问题。下面是我从无数个调试夜晚中总结出的经验。

5.1 元素定位失败：最常见也最头疼

问题：NoSuchElementException或TimeoutException。

排查清单：

1. 定位器是否正确？：这是第一怀疑对象。用浏览器的开发者工具（F12）重新检查元素的id、name、class、xpath或css selector。注意：动态生成的ID（包含时间戳或随机数）绝对不能用。
2. 页面是否加载完成？：你的操作速度可能比页面渲染快。确保在操作前使用了正确的等待。优先使用等待特定元素出现，而不是等待固定时间或整个页面加载。
3. 元素是否在iframe或shadow DOM内？：如果在，必须先切换到对应的iframe或穿透shadow root才能定位到内部元素。

   # 切换iframe iframe = driver.find_element(By.TAG_NAME, "iframe") driver.switch_to.frame(iframe) # 操作iframe内的元素... driver.switch_to.default_content() # 操作完切回来

4. 元素是否被遮挡？：其他元素（如弹窗、遮罩层）盖住了你要操作的元素。需要先关闭或处理遮挡物。
5. 浏览器窗口大小？：某些响应式页面，元素在小窗口下可能被隐藏或改变布局。尝试driver.maximize_window()或在固定尺寸下运行。

调试技巧：在find_element失败时，你的BasePage应该已经自动截图。查看截图能直观看到失败瞬间的页面状态。此外，可以在失败前手动打印当前页面的driver.page_source（HTML源码）和driver.current_url，与预期进行对比。

5.2 测试用例间的状态污染

问题：一个测试用例登录后，没有正确退出，导致下一个用例在已登录状态下运行，结果出错。

解决方案：

• 使用pytest夹具的scope和autouse：对于登录这类需要初始状态的操作，可以写一个autouse的session或function级别的夹具，在每个用例开始前强制回到未登录状态。

  @pytest.fixture(scope="function", autouse=True) def logout_before_each_test(driver): """每个测试函数执行前，都尝试退出登录，清理状态""" yield # 在每个测试结束后执行清理 try: # 访问登出URL，或点击登出按钮 driver.get("https://www.example.com/logout") except Exception: pass # 如果已经未登录，忽略错误

• 使用浏览器无痕模式或每次新建driver：将driver夹具的scope设为function，这样每个测试都会有一个全新的浏览器会话，完全隔离。但这会牺牲一些执行速度。

5.3 如何处理动态内容和异步加载

现代前端框架（React, Vue, Angular）大量使用异步加载，元素不会一次性全部出现。

策略：

• 等待特定元素：这是黄金法则。等待代表该部分内容加载完成的关键元素出现。
• 等待旧元素消失：在页面跳转或内容刷新时，等待代表旧内容的元素消失，也是一个有效的信号。
• 谨慎使用driver.implicitly_wait：设置一个较小的全局隐式等待（如5秒）作为兜底策略可以，但绝不能依赖它。显式等待才是精准控制的主力。
• 监听网络请求：对于更复杂的情况，可以通过Selenium的performance log或DevTools Protocol来监听特定的XHR/Fetch请求完成，作为等待条件。但这属于高级技巧。

5.4 提高测试稳定性和执行速度

稳定性：

• 定位器策略：优先级：ID > Name > CSS Selector > XPath。CSS Selector通常比XPath性能更好、更易读。避免使用包含索引（如div[1]）或过于复杂的XPath，它们非常脆弱。
• 原子操作：每个页面对象方法应尽可能独立和原子化。一个方法只做一件事，并做好它。避免长链式操作。
• 断言时机：在关键状态变化后（如点击按钮、提交表单），添加合理的断言或等待，确保应用状态已更新，再进行下一步。

速度：

• 使用无头浏览器（Headless）：在CI/CD管道中运行时，使用--headless模式可以显著加快速度，且不占用GUI资源。
• 并行测试：pytest支持通过pytest-xdist插件并行运行测试。确保你的测试用例是独立的（无状态污染），就能充分利用多核CPU。
• 优化等待：将默认的显式等待超时时间设置为一个合理的值（如5-10秒），而不是盲目地用30秒。对于已知很快的操作，可以单独设置更短的等待。

5.5 PO模式不是银弹：何时不用或慎用？

PO模式很好，但并非所有情况都适用。

• 一次性脚本或探索性测试：如果你只是写个临时脚本抓点数据，或者快速验证一个想法，直接写线性代码更快捷。
• 极其简单的页面或项目：如果整个应用就两三个页面，且UI极其稳定，引入完整的PO框架可能显得“杀鸡用牛刀”。
• 对测试代码可维护性要求极低的场景：比如一个即将下线的项目。

但是，对于任何有中期或长期维护计划的、页面数量超过5个的Web应用自动化测试项目，从一开始就采用PO模式，绝对是性价比最高的选择。它前期多花的一点设计时间，会在第一次UI变更时就成倍地赚回来。