Python自动化测试实战：pytest+Selenium+PO模式构建高效Web测试框架

1. 项目概述：为什么我们需要自动化测试框架？

干了这么多年测试，从手工点点点到写脚本，再到搭建完整的自动化测试体系，我最大的感触是：工具和框架的选择，直接决定了你后续的维护成本和团队效率。很多刚入行的朋友，一提到Python自动化测试，脑子里可能立刻蹦出好几个名词：unittest、pytest、Selenium。它们之间是什么关系？我该用哪个？今天，我就结合自己踩过的坑和实际项目经验，把这套组合拳给你拆解明白。

简单来说，unittest是Python自带的“官方”单元测试框架，提供了测试用例、测试套件、断言等基础骨架，但用起来有点“老派”和繁琐。pytest则是社区里更受欢迎的“后起之秀”，它语法更简洁、插件生态丰富，能轻松搞定参数化、夹具（fixture）等复杂场景，是目前功能测试和接口自动化的主流选择。而Selenium是一个专门用于Web应用UI自动化测试的工具库，它本身不是测试框架，而是驱动浏览器进行模拟操作的“手”。在实际项目中，我们通常会用pytest（或unittest）作为测试的组织和执行框架，然后调用Selenium的API来完成具体的页面操作和验证。

所以，这个实战项目的核心，就是教你如何将这三者有机结合起来，搭建一个高效、可维护的Web自动化测试工程。无论你是想提升个人技能，还是为团队引入自动化测试流程，这套组合都能提供坚实的支撑。接下来，我会从环境搭建、框架对比、核心实战到高级技巧，一步步带你走完整个流程。

2. 环境准备与工具选型：打造稳固的测试基石

工欲善其事，必先利其器。在开始写第一行测试代码之前，一个清晰、隔离且可复现的测试环境至关重要。这一步没做好，后面可能会遇到各种诡异的“在我的机器上能跑”的问题。

2.1 Python环境与包管理

首先，我强烈建议使用虚拟环境（Virtual Environment）来隔离项目依赖。这能避免不同项目间Python包的版本冲突。现在更推荐使用venv（Python 3.3+内置）或者conda（如果你同时涉及数据科学）。

# 创建虚拟环境 python -m venv venv_auto_test # 激活虚拟环境 (Windows) venv_auto_test\Scripts\activate # 激活虚拟环境 (macOS/Linux) source venv_auto_test/bin/activate

激活后，你的命令行提示符前会出现(venv_auto_test)字样，表示已进入该环境。接下来，使用pip安装核心依赖。我习惯先创建一个requirements.txt文件来管理依赖，这样团队其他成员可以一键复现环境。

# requirements.txt pytest>=7.0.0 selenium>=4.0.0 webdriver-manager>=3.0.0 # 自动管理浏览器驱动，强烈推荐！ pytest-html>=3.0.0 # 生成HTML测试报告 pytest-xdist>=2.0.0 # 测试并行化，提升执行速度

然后执行安装：

pip install -r requirements.txt

这里重点说一下webdriver-manager这个库。早期做Selenium自动化，最头疼的就是浏览器版本升级后，对应的chromedriver驱动也要手动下载、替换路径，非常麻烦。webdriver-manager完美解决了这个问题，它能自动检测你本地安装的浏览器版本，并下载匹配的驱动，省心省力。

2.2 开发工具与浏览器选择

对于IDE，VS Code和PyCharm都是极好的选择。VSCode轻量、插件丰富，配置Python环境也很简单。PyCharm作为专业的Python IDE，对测试框架的支持更原生，比如可以直接右键运行pytest用例。根据个人习惯选择即可。

浏览器方面，Chrome或Edge（Chromium内核）是首选，因为它们的开发者工具最强大，社区支持也最好。Firefox也可以，但有时会遇到一些细微的兼容性问题。确保你的浏览器已更新到较新的稳定版本。

注意：在公司内网环境或CI/CD流水线中，可能需要使用无头模式（Headless）运行测试，即不显示浏览器UI。这时webdriver-manager同样能工作，你只需要在代码中配置相应的选项即可。

3. 测试框架深度对比：unittest vs pytest

在真正动手之前，我们必须理解为什么现在更推荐pytest，而不是Python自带的unittest。这不仅仅是潮流，更是效率和工程化的考量。

3.1 unittest：经典但繁琐

unittest是仿照Java的JUnit设计的，采用了面向对象的方式。一个典型的unittest测试用例长这样：

import unittest class TestMathOperations(unittest.TestCase): def setUp(self): # 每个测试方法执行前运行 self.calculator = Calculator() def test_addition(self): result = self.calculator.add(2, 3) self.assertEqual(result, 5) # 断言 def test_subtraction(self): result = self.calculator.subtract(5, 3) self.assertTrue(result == 2) def tearDown(self): # 每个测试方法执行后运行 del self.calculator if __name__ == '__main__': unittest.main()

它的优点：

1. 无需额外安装，Python标准库自带。
2. 结构清晰，有固定的setUp和tearDown生命周期。
3. 断言方法丰富（assertEqual,assertTrue,assertIn等）。

它的缺点：

1. 样板代码多：必须继承unittest.TestCase，方法名必须以test_开头。
2. 夹具（Fixture）能力弱：setUp/tearDown是类级别的，如果想为单个方法定制前置后置操作，或者实现模块级、会话级的夹具，非常麻烦。
3. 参数化测试不友好：需要借助ddt等第三方库，原生支持差。
4. 插件生态匮乏：生成漂亮报告、并发执行等功能需要自己造轮子或整合其他工具。

3.2 pytest：现代而强大

pytest几乎解决了unittest的所有痛点，它的哲学是“让测试变得简单有趣”。同样的功能，用pytest实现：

# 不需要继承任何类 def test_addition(): calculator = Calculator() result = calculator.add(2, 3) assert result == 5 # 使用简单的assert语句即可 # 使用夹具(fixture)管理资源 import pytest @pytest.fixture def calculator(): return Calculator() # 相当于setUp # yield calculator 之后可以写清理代码，相当于tearDown def test_subtraction(calculator): # 夹具通过参数注入 result = calculator.subtract(5, 3) assert result == 2 # 轻松的参数化测试 @pytest.mark.parametrize("a,b,expected", [(1,2,3), (4,5,9)]) def test_add_multiple(calculator, a, b, expected): assert calculator.add(a, b) == expected

pytest的压倒性优势：

1. 语法极其简洁：不需要类，断言直接用assert，失败时pytest能给出非常详细的差异对比。
2. 强大的夹具系统：@pytest.fixture装饰器可以定义不同作用域（函数、类、模块、会话）的夹具，并通过依赖注入的方式优雅地在测试用例中使用，这是实现测试数据准备、环境初始化的核心利器。
3. 原生支持参数化：@pytest.mark.parametrize让数据驱动测试变得轻而易举。
4. 丰富的插件生态：有超过1000个插件，可以轻松实现HTML报告 (pytest-html)、并发执行 (pytest-xdist)、控制用例执行顺序 (pytest-ordering)、失败重试 (pytest-rerunfailures) 等高级功能。
5. 智能发现测试：能自动发现以test_开头的文件和函数，也支持Test开头的类。

实操心得：在新项目中，毫不犹豫地选择pytest。对于遗留的unittest项目，pytest也能直接运行unittest风格的测试用例，兼容性很好，可以逐步迁移。从团队协作和长期维护的角度看，pytest带来的效率提升是巨大的。

4. Selenium核心操作与页面对象模型（PO）设计

Selenium是我们与浏览器交互的“手”。但直接在被测页面上“裸写”查找元素和操作语句，是自动化项目最终走向混乱和不可维护的根源。我们必须引入页面对象模型（Page Object Model, PO）这一核心设计模式。

4.1 Selenium WebDriver 基础操作

在引入PO之前，先快速过一下Selenium的常用操作，这些是PO模型里的“砖块”。

from selenium import webdriver from selenium.webdriver.common.by import By from selenium.webdriver.support.ui import WebDriverWait from selenium.webdriver.support import expected_conditions as EC from webdriver_manager.chrome import ChromeDriverManager from selenium.webdriver.chrome.service import Service # 使用webdriver-manager自动管理驱动 service = Service(ChromeDriverManager().install()) driver = webdriver.Chrome(service=service) try: driver.get("https://www.example.com") # 1. 元素定位（八大定位方式，优先使用ID、CSS Selector、XPath） element_by_id = driver.find_element(By.ID, “username”) element_by_css = driver.find_element(By.CSS_SELECTOR, “input.login-form”) element_by_xpath = driver.find_element(By.XPATH, “//button[text()=‘登录’]”) # 2. 元素操作 element_by_id.send_keys(“my_username”) # 输入文本 element_by_css.click() # 点击 element_by_xpath.clear() # 清空输入框 # 3. 等待机制 - 这是UI自动化的重中之重！ # 隐式等待：全局设置，查找元素时最多等待N秒 driver.implicitly_wait(10) # 显式等待：针对某个条件进行等待，更灵活、更推荐 wait = WebDriverWait(driver, 10) submit_button = wait.until( EC.element_to_be_clickable((By.ID, “submit-btn”)) ) submit_button.click() # 等待元素可见、存在、包含特定文本等 success_msg = wait.until( EC.visibility_of_element_located((By.CLASS_NAME, “success”)) ) assert “登录成功” in success_msg.text finally: driver.quit() # 务必退出，释放资源

关于等待的黄金法则：永远不要使用time.sleep()！这是UI自动化脚本脆弱（flaky）的主要原因。页面加载速度和元素出现时间是不确定的。隐式等待设一个兜底时间，显式等待用于关键操作前的条件检查，两者结合使用能极大提升脚本的稳定性和执行速度。

4.2 页面对象模型（PO）设计与实现

PO模型的核心思想是将页面封装成对象，将页面元素定位和元素操作封装在这个对象的方法中。测试用例只关心业务逻辑（做什么），而不关心具体怎么做（如何定位、如何操作）。

一个经典的PO结构如下：

project/ ├── pages/ # 页面对象类 │ ├── __init__.py │ ├── base_page.py # 基础页面类 │ ├── login_page.py │ └── home_page.py ├── tests/ # 测试用例 │ ├── __init__.py │ └── test_login.py ├── conftest.py # pytest全局夹具配置 └── requirements.txt

1. 基础页面类 (base_page.py)：封装所有页面共用的操作，如元素查找、等待、点击等。

from selenium.webdriver.support.ui import WebDriverWait from selenium.webdriver.support import expected_conditions as EC class BasePage: def __init__(self, driver): self.driver = driver self.wait = WebDriverWait(driver, 10) def find_element(self, by, locator): """查找单个元素，加入显式等待""" return self.wait.until(EC.presence_of_element_located((by, locator))) def find_elements(self, by, locator): """查找多个元素""" return self.wait.until(EC.presence_of_all_elements_located((by, locator))) def click(self, by, locator): """点击元素，确保可点击""" element = self.wait.until(EC.element_to_be_clickable((by, locator))) element.click() def input_text(self, by, locator, text): """输入文本，先清空""" element = self.find_element(by, locator) element.clear() element.send_keys(text)

2. 具体页面类 (login_page.py)：继承基础页面类，定义特定页面的元素和操作。

from selenium.webdriver.common.by import By from .base_page import BasePage class LoginPage(BasePage): # 页面元素定位器（Locator），集中管理，便于维护 USERNAME_INPUT = (By.ID, “username”) PASSWORD_INPUT = (By.ID, “password”) LOGIN_BUTTON = (By.XPATH, “//button[@type=‘submit’]”) ERROR_MSG = (By.CLASS_NAME, “error-message”) def __init__(self, driver): super().__init__(driver) self.driver = driver def open(self, url): self.driver.get(url) return self 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) return self def get_error_message(self): """获取错误提示文本""" try: return self.find_element(*self.ERROR_MSG).text except: return “” # 如果没有错误信息，返回空字符串

3. 测试用例 (test_login.py)：使用页面对象，编写清晰业务逻辑的测试。

import pytest from pages.login_page import LoginPage from pages.home_page import HomePage class TestLogin: @pytest.fixture(autouse=True) def setup(self, driver): # driver夹具来自conftest.py self.login_page = LoginPage(driver) self.home_page = HomePage(driver) self.login_page.open(“https://example.com/login”) def test_login_success(self): """测试正常登录流程""" self.login_page.enter_username(“valid_user”)\ .enter_password(“valid_pass”)\ .click_login() # 断言：登录成功后应跳转到首页，并显示用户名 assert self.home_page.is_user_logged_in(“valid_user”) @pytest.mark.parametrize(“username, password, expected_error”, [ (“”, “somepass”, “用户名不能为空”), (“user”, “”, “密码不能为空”), (“wrong”, “wrong”, “用户名或密码错误”), ]) def test_login_failure(self, username, password, expected_error): """参数化测试登录失败场景""" self.login_page.enter_username(username)\ .enter_password(password)\ .click_login() # 断言：页面应显示预期的错误信息 actual_error = self.login_page.get_error_message() assert expected_error in actual_error

PO模式的好处：

• 高可维护性：当页面UI元素发生变化时，只需修改对应页面对象类中的定位器，所有测试用例无需改动。
• 高可读性：测试用例读起来像自然语言，清晰表达了“在登录页面输入用户名和密码，然后点击登录”的业务意图。
• 低冗余：公共操作封装在基础页面类中，避免了代码重复。
• 便于协作：前端开发改UI，测试只需改PO类，分工明确。

5. 使用pytest夹具（Fixture）管理测试生命周期

pytest的夹具系统是它的灵魂。在自动化测试中，我们常用夹具来管理测试资源，如WebDriver实例、数据库连接、测试数据等。conftest.py文件用于存放被多个测试文件共享的夹具。

5.1 定义全局夹具 (conftest.py)

# conftest.py import pytest from selenium import webdriver from selenium.webdriver.chrome.options import Options from selenium.webdriver.chrome.service import Service from webdriver_manager.chrome import ChromeDriverManager @pytest.fixture(scope=“session”) # 会话级，所有测试只执行一次 def chrome_options(): """配置浏览器选项""" options = Options() options.add_argument(“--start-maximized”) # 启动最大化 # options.add_argument(“--headless”) # 无头模式，用于CI环境 options.add_argument(“--disable-gpu”) options.add_argument(“--no-sandbox”) # Linux环境下可能需要 options.add_argument(“--disable-dev-shm-usage”) # 解决Docker内存不足问题 # 禁用浏览器日志，减少干扰 options.add_experimental_option(“excludeSwitches”, [“enable-logging”]) return options @pytest.fixture(scope=“function”) # 函数级，每个测试函数执行一次 def driver(chrome_options): """创建和退出WebDriver实例""" service = Service(ChromeDriverManager().install()) driver = webdriver.Chrome(service=service, options=chrome_options) yield driver # 测试函数在此处执行 # 测试函数执行完毕后，执行清理工作 driver.quit() @pytest.fixture def login_user(driver): """一个业务级别的夹具：预先登录用户""" from pages.login_page import LoginPage from pages.home_page import HomePage login_page = LoginPage(driver) home_page = HomePage(driver) login_page.open(“https://example.com/login”) login_page.enter_username(“test_user”).enter_password(“test_pass”).click_login() # 确保登录成功 assert home_page.is_user_logged_in() return home_page # 将登录后的首页对象提供给测试用例

夹具作用域（scope）详解：

• function（默认）：每个测试函数运行一次。
• class：每个测试类运行一次。
• module：每个.py文件运行一次。
• session：一次pytest执行（可能包含多个文件）只运行一次。

选择策略：driver夹具通常用function作用域，保证每个测试用例都在全新的浏览器环境中运行，相互隔离。chrome_options用session作用域，因为配置只需读取一次。login_user这类业务夹具，根据测试需求选择function或class作用域。

5.2 夹具在测试中的使用

夹具通过测试函数的参数自动注入。pytest的依赖注入机制会自动寻找同名的夹具并执行它。

# test_with_fixture.py def test_using_driver_fixture(driver): """直接使用driver夹具""" driver.get(“https://www.baidu.com”) assert “百度” in driver.title def test_using_business_fixture(login_user): """使用业务夹具login_user，它返回了已登录的HomePage对象""" home_page = login_user # 直接进行登录后的操作，比如检查消息数量 unread_count = home_page.get_unread_message_count() assert unread_count >= 0 class TestComplexScenario: @pytest.fixture(autouse=True) # autouse=True 让该夹具自动应用于类中所有方法 def setup_class(self, driver): """类级别的自动使用夹具""" self.driver = driver self.driver.get(“https://example.com”) def test_something(self): # 可以直接使用self.driver assert self.driver.current_url == “https://example.com”

实操心得：合理设计夹具的层次和依赖关系。将浏览器初始化、用户登录、数据准备等步骤封装成不同作用域的夹具，能让测试用例的“准备（Arrange）”部分变得极其简洁，专注于“执行（Act）”和“断言（Assert）”。这也是测试代码“干净”的重要标志。

6. 高级技巧与工程化实践

当基础框架搭好，用例写了几十个之后，你就会开始关注如何让测试套件更健壮、执行更快、报告更直观、更容易集成到CI/CD中。

6.1 参数化与数据驱动测试

数据驱动测试（DDT）是将测试数据与测试逻辑分离的最佳实践。pytest的@pytest.mark.parametrize装饰器是原生支持。

import pytest import csv # 1. 直接参数化 @pytest.mark.parametrize(“search_keyword, expected_count”, [ (“pytest”, 1000), (“selenium”, 2000), (“自动化测试”, 500), ]) def test_search_result_count(home_page, search_keyword, expected_count): """测试搜索不同关键词的结果数量""" result_page = home_page.search_for(search_keyword) actual_count = result_page.get_result_count() assert actual_count >= expected_count # 2. 从外部文件（如CSV、JSON）读取测试数据 def load_test_data_from_csv(): with open(‘test_data/login_cases.csv’, ‘r’, encoding=‘utf-8’) as f: reader = csv.DictReader(f) return list(reader) @pytest.mark.parametrize(“data”, load_test_data_from_csv()) def test_login_with_external_data(login_page, data): login_page.enter_username(data[‘username’])\ .enter_password(data[‘password’])\ .click_login() if data[‘should_succeed’] == ‘True’: assert login_page.is_login_successful() else: assert data[‘expected_error’] in login_page.get_error_message()

数据管理建议：对于简单的几组数据，直接写在装饰器里。对于大量、复杂的测试数据（如边界值、组合测试），强烈建议使用外部文件（CSV、JSON、YAML）或数据库管理，并使用夹具来读取和提供这些数据。

6.2 测试报告生成与美化

生成的测试报告是向团队展示自动化测试价值的重要产出。pytest-html插件可以生成直观的HTML报告。

首先安装插件：pip install pytest-html。

然后通过命令行参数或pytest.ini配置文件来生成报告：

# 命令行执行并生成报告 pytest tests/ --html=reports/report.html --self-contained-html

--self-contained-html参数会将CSS样式内联到HTML中，生成一个独立的文件，方便分享。

你还可以在conftest.py中钩住pytest的钩子函数，对报告进行自定义，比如添加环境信息、截图等。

# conftest.py import pytest from datetime import datetime from selenium import webdriver @pytest.hookimpl(hookwrapper=True) def pytest_runtest_makereport(item, call): """在测试用例生成报告时，如果失败则自动截图""" pytest_html = item.config.pluginmanager.getplugin(“html”) outcome = yield report = outcome.get_result() extra = getattr(report, “extra”, []) if report.when == “call” and report.failed: # 获取测试用例中的driver夹具（需要一些技巧来获取） for name, fixturedef in item._request._fixturedefs.items(): if hasattr(fixturedef.func, “__name__”) and fixturedef.func.__name__ == “driver”: driver_fixture = item._request.getfixturevalue(name) if isinstance(driver_fixture, webdriver.remote.webdriver.WebDriver): screenshot = driver_fixture.get_screenshot_as_base64() extra.append(pytest_html.extras.image(screenshot, “失败截图”)) report.extra = extra

6.3 测试并行执行与调度

当测试用例成百上千时，串行执行会非常耗时。pytest-xdist插件可以实现测试的并行执行，充分利用多核CPU。

安装：pip install pytest-xdist

# 使用2个worker并行执行 pytest tests/ -n 2 # 自动检测CPU核心数 pytest tests/ -n auto

并行执行的注意事项：

1. 测试独立性：并行执行的前提是测试用例之间没有依赖，不共享状态。这正是我们使用function作用域的driver夹具和PO模型所倡导的。
2. 资源竞争：如果测试涉及对同一共享资源（如测试数据库的某条特定记录）的写操作，需要设计不同的测试数据或用程序锁来避免冲突。
3. 结果合并：pytest-xdist会自动合并测试结果，pytest-html生成的报告也是合并后的总报告。

6.4 集成到CI/CD流水线

自动化测试只有集成到持续集成/持续部署（CI/CD）流水线中，才能发挥最大价值，实现“质量门禁”。以GitHub Actions为例，一个简单的配置如下：

# .github/workflows/python-test.yml name: Python Automated Tests on: [push, pull_request] jobs: test: runs-on: ubuntu-latest strategy: matrix: python-version: [“3.9”, “3.10”] # 多版本Python测试 steps: - uses: actions/checkout@v3 - name: Set up Python ${{ matrix.python-version }} uses: actions/setup-python@v4 with: python-version: ${{ matrix.python-version }} - name: Install dependencies run: | python -m pip install --upgrade pip pip install -r requirements.txt - name: Install Chrome and ChromeDriver run: | sudo apt-get update sudo apt-get install -y google-chrome-stable - name: Run tests with pytest run: | # 无头模式运行测试，生成HTML和JUnit XML报告（后者便于CI平台解析） pytest tests/ \ --headless \ --html=report.html \ --junitxml=junit-report.xml \ -n auto - name: Upload test report uses: actions/upload-artifact@v3 if: always() # 即使测试失败也上传报告 with: name: test-report-${{ matrix.python-version }} path: | report.html junit-report.xml

在这个流程中，每次代码推送或拉取请求都会触发自动化测试。测试在纯净的Ubuntu容器中运行，安装依赖和浏览器，然后以无头模式并行执行所有测试用例，并生成报告。junit-report.xml是一种标准格式，可以被Jenkins、GitLab CI等平台解析，以可视化形式展示测试通过率、趋势等。

7. 常见问题排查与调试技巧实录

即使框架设计得再好，编写UI自动化测试也难免遇到元素找不到、脚本不稳定等问题。下面是我积累的一些常见问题及其解决方法。

7.1 元素定位失败问题

这是最常见的问题，错误信息通常是NoSuchElementException。

可能原因及解决方案：

调试技巧：在测试失败时，让脚本暂停并进入交互模式，可以手动检查页面状态。

import pdb; pdb.set_trace() # 在代码中插入断点 # 或者使用更强大的IPython嵌入 from IPython import embed; embed()

此时，你可以在终端里直接使用driver对象尝试不同的定位方式，查看页面HTML (driver.page_source)，或者截图 (driver.save_screenshot(‘debug.png’))。

7.2 测试脚本不稳定（Flaky Tests）

脚本有时成功有时失败，是最让人头疼的。

应对策略：

1. 强化等待：检查所有交互操作前是否都有合适的显式等待。不仅仅是元素存在，还要考虑可点击（clickable）、可见（visible）等状态。
2. 重试机制：对于非功能性的偶发失败（如网络抖动），可以使用pytest-rerunfailures插件自动重试失败的用例。

   pip install pytest-rerunfailures pytest --reruns 3 --reruns-delay 2 # 失败后重试3次，每次间隔2秒

3. 隔离测试环境：确保测试用例之间完全独立。使用function作用域的夹具为每个测试提供新的浏览器实例和用户会话。
4. 清理测试数据：每个测试开始前，通过夹具或setup_method将数据库或应用状态恢复到已知的干净状态。
5. 禁用动画和视频：复杂的CSS动画或自动播放的视频可能干扰元素交互。可以在浏览器选项中添加参数来禁用它们（如果被测应用允许）。

   prefs = { “profile.managed_default_content_settings.images”: 2, # 可选：禁用图片加速 “intl.accept_languages”: “en,en_US”, } options.add_experimental_option(“prefs”, prefs)

7.3 性能优化与执行速度

测试套件越来越庞大，执行时间也会变长。

优化手段：

1. 并行执行：如前所述，使用pytest-xdist。
2. 减少不必要的操作：例如，如果只是测试某个页面功能，能否直接用夹具导航到该页面，而不是每次都从首页登录开始？
3. 使用API准备数据：UI操作很慢。在测试前置条件中（如创建测试用户、准备测试订单），尽量调用后端API或直接操作数据库，而不是通过UI界面一步步操作。
4. 选择性运行测试：使用pytest标记（mark）来分类测试，如@pytest.mark.slow、@pytest.mark.quick。然后通过-m参数只运行需要的测试集。

   pytest -m “not slow” # 运行所有非慢速测试 pytest -m “login” # 只运行标记为login的测试

7.4 浏览器驱动与版本兼容性

这是另一个常见的“坑”，但使用webdriver-manager后已大大缓解。如果还遇到问题：

1. 检查浏览器是否自动更新到了不兼容的版本。可以尝试在CI脚本中固定浏览器版本。
2. 确保webdriver-manager已更新到最新版本 (pip install -U webdriver-manager)。
3. 在极少数网络环境下，webdriver-manager可能无法从官方源下载驱动。可以配置镜像源，或者手动下载驱动并指定路径。

   # 手动指定驱动路径 service = Service(executable_path=‘/path/to/your/chromedriver’) driver = webdriver.Chrome(service=service)

8. 总结与个人体会

走完这一整套流程，从环境搭建、框架选型、PO设计、夹具使用到CI集成和问题排查，一个健壮、可维护的Web自动化测试项目骨架就清晰了。回顾这些年，我觉得自动化测试成功的关键，技术选型只占三成，剩下的七成是工程化思维和团队协作。

技术层面，pytest+Selenium+PO的组合是目前Python生态下经过无数项目验证的“黄金搭档”。pytest提供优雅的测试组织和执行能力，Selenium提供强大的浏览器操控能力，PO模式则保证了代码在面对频繁UI变更时的韧性。把这套组合拳打熟，足以应对绝大多数Web应用的自动化测试需求。

工程层面，比写用例更重要的是设计。如何设计夹具来管理测试生命周期？如何组织测试数据和用例结构，让新人也能快速上手？如何将测试报告集成到团队协作工具（如Slack、钉钉）中？如何制定测试失败后的排查流程？这些问题，往往需要在项目初期就和团队一起定好规范。

最后，自动化测试不是银弹，不能100%替代手工测试。它的价值在于解放人力，让测试人员从重复的回归测试中解脱出来，去从事更有价值的探索性测试、用户体验测试和测试设计工作。因此，在决定自动化什么的时候，要优先选择那些稳定、核心、高频的业务流程。对于那些变动极其频繁的页面或功能，自动化的维护成本可能会超过其收益，这时更需要谨慎评估。

我个人最深的体会是，一个好的自动化测试项目，其代码应该像产品代码一样被对待：有清晰的架构、有代码审查、有版本控制、有持续集成。它不仅仅是测试，它本身就是一份宝贵的、可执行的系统文档。当你看到CI流水线绿灯通过，或者通过一封自动发送的测试报告邮件就了解了本次构建的质量时，那种成就感，就是坚持做下去的最大动力。