用 pytest-playwright + AI 让自动化测试脚本"自动繁殖"：测试工程师的终极摸鱼指南

前言：一个测试工程师的觉醒时刻

各位测试圈的兄弟姐妹们，大家好。

先问你们一个问题：你现在写一个 UI 自动化测试用例，平均需要多久？

如果你的答案是"半小时到一小时"，恭喜你，你已经打败了 80% 的同行——因为他们根本不写 UI 自动化测试，全靠手工点点点。

但如果你告诉我"几分钟"，那你大概率已经用上了某些 AI 工具。不过别急，今天我要介绍的方案，能把这个时间压缩到十几秒，而且生成的代码还能直接跑。

是的，你没看错。十几秒，一个完整的、可运行的、带断言的 Playwright 测试用例。

这不是科幻，这是 2026 年测试工程师的日常。

今天我们要聊的主角是：pytest-playwright + AI 驱动的测试生成。这套组合拳打下来，你会发现——以前你写测试是在"搬砖"，现在你写测试是在"监工"。

免责声明： 本文提到的"摸鱼"纯属修辞手法。作者不鼓励在工作时间摸鱼。但如果你用 AI 写完测试后多出来的时间用来喝咖啡，我完全理解。

---

第一章：pytest-playwright 是什么？为什么它比 Selenium 香？

1.1 Selenium 的"中年危机"

说到 UI 自动化测试，Selenium 就像你那个干了十年的同事——经验丰富，但越来越力不从心：

• 启动速度慢： 一个 webdriver.Chrome() 能让你等出一杯咖啡的时间
• 等待地狱： time.sleep(3) 是 Selenium 代码里出现频率最高的语句，没有之一
• 定位器脆弱： XPath 写得像天书，页面一改全军覆没
• 并发困难： 想跑个并行测试？先准备三台机器吧

Selenium 没有错，它只是老了。就像翻盖手机一样，它曾经很伟大，但现在是智能手机的时代。

1.2 Playwright：后浪中的后浪

Playwright 是微软在 2020 年开源的浏览器自动化框架，到 2026 年，它已经是 UI 自动化测试的绝对主流。它的优势用一句话概括：Selenium 能做的事它都能做，而且做得更快更稳更优雅。

核心优势：

特性	Selenium	Playwright
启动速度	慢（2-5秒）	快（<1秒）
自动等待	❌ 手动等	✅ 内置智能等待
并行测试	复杂	原生支持
浏览器支持	Chrome/Firefox/Edge	Chrome/Firefox/Edge/WebKit
网络拦截	需要额外库	内置
代码生成器	❌	✅ playwright codegen
Trace 录制	❌	✅ 内置 trace viewer

而 pytest-playwright 则是 Playwright 的 Python pytest 插件，让你可以用最 Pythonic 的方式写测试：

import pytest

def test_homepage(page):
    page.goto("https://example.com")
    assert page.title() == "Example Domain"

就这么多。不需要 setUp、tearDown，不需要手动管理浏览器生命周期。page 这个 fixture 自动帮你搞定一切。

1.3 为什么选 pytest-playwright + AI？

因为它是最适合让 AI 来写测试的框架：

1. 代码简洁： AI 生成的代码越简洁，出错概率越低
2. 声明式风格： “点击这个按钮”、“填写这个表单”、“断言这个文本”——这不就是自然语言吗？
3. 自动等待： 不需要 AI 学会写 wait_for_selector，Playwright 自动等
4. 内置断言： expect() API 让断言语义清晰

---

第二章：环境搭建——5 分钟从零到能跑

2.1 安装依赖

# 创建虚拟环境（强烈建议，不要污染全局环境）
python -m venv venv
source venv/bin/activate  # Windows: venv\Scripts\activate

# 安装 pytest-playwright
pip install pytest-playwright

# 安装浏览器（只需执行一次）
playwright install

就这么简单。不需要下载 WebDriver，不需要配置环境变量，不需要在 Stack Overflow 上搜"ChromeDriver version mismatch"。

你知道 Selenium 用户一生中花在配环境上的时间有多少吗？据统计，平均每人 47 小时。 这 47 小时够你学一门新语言了。

2.2 项目结构

ai_test_project/
├── conftest.py          # 全局 fixtures
├── pytest.ini           # pytest 配置
├── tests/
│   ├── test_login.py    # 登录测试
│   ├── test_search.py   # 搜索测试
│   └── test_cart.py     # 购物车测试
├── pages/               # Page Object（可选）
│   ├── login_page.py
│   └── search_page.py
└── ai_generator/        # AI 测试生成器
    └── generator.py

2.3 pytest 配置

# pytest.ini
[pytest]
addopts = --browser chromium --headed --screenshot on --video on

配置项解释：

• --browser chromium：默认用 Chromium 浏览器
• --headed：有头模式，可以看到浏览器操作（调试时用）
• --screenshot on：失败时自动截图
• --video on：自动录制视频

这些配置在 Selenium 时代需要写几十行代码，在 pytest-playwright 里只需要一行配置。

---

第三章：AI 测试生成器——让 AI 替你写测试

3.1 核心思路

我们要做的不是简单的"录屏回放"，而是让 AI 理解页面结构，然后自动生成测试代码。

流程是这样的：

页面 URL → Playwright 提取页面信息 → 发送给 AI → AI 生成 pytest 代码 → 保存并运行

3.2 完整代码实现

"""
AI 测试生成器：用 Playwright 提取页面信息，用 AI 自动生成 pytest-playwright 测试代码
"""
import asyncio
import json
import os
from pathlib import Path
from playwright.async_api import async_playwright
import httpx


class PageAnalyzer:
    """页面分析器：提取页面的可交互元素信息"""

    def __init__(self):
        self.playwright = None
        self.browser = None

    async def __aenter__(self):
        self.playwright = await async_playwright().start()
        self.browser = await self.playwright.chromium.launch(headless=True)
        return self

    async def __aexit__(self, *args):
        await self.browser.close()
        await self.playwright.stop()

    async def analyze(self, url: str) -> dict:
        """分析页面，提取所有可交互元素的信息"""
        page = await self.browser.new_page()
        await page.goto(url, wait_until="networkidle")

        # 提取页面信息
        page_info = await page.evaluate("""
        () => {
            const info = {
                title: document.title,
                url: window.location.href,
                buttons: [],
                inputs: [],
                links: [],
                selects: [],
                forms: []
            };

            // 提取按钮
            document.querySelectorAll('button, [role="button"], input[type="submit"]').forEach(el => {
                info.buttons.push({
                    text: el.textContent?.trim() || el.value || '',
                    id: el.id || '',
                    class: el.className || '',
                    tag: el.tagName.toLowerCase(),
                    type: el.type || ''
                });
            });

            // 提取输入框
            document.querySelectorAll('input, textarea').forEach(el => {
                if (el.type === 'hidden' || el.type === 'submit') return;
                info.inputs.push({
                    name: el.name || '',
                    id: el.id || '',
                    type: el.type || 'text',
                    placeholder: el.placeholder || '',
                    label: el.labels?.[0]?.textContent?.trim() || '',
                    class: el.className || ''
                });
            });

            // 提取链接（前20个有意义的）
            document.querySelectorAll('a[href]').forEach(el => {
                const text = el.textContent?.trim();
                if (text && text.length > 1 && text.length < 50) {
                    info.links.push({
                        text: text,
                        href: el.href,
                        id: el.id || ''
                    });
                }
            });

            // 提取下拉选择框
            document.querySelectorAll('select').forEach(el => {
                const options = [];
                el.querySelectorAll('option').forEach(opt => {
                    options.push({ text: opt.textContent.trim(), value: opt.value });
                });
                info.selects.push({
                    name: el.name || '',
                    id: el.id || '',
                    options: options
                });
            });

            // 限制数量，避免信息过载
            info.buttons = info.buttons.slice(0, 15);
            info.inputs = info.inputs.slice(0, 15);
            info.links = info.links.slice(0, 20);
            info.selects = info.selects.slice(0, 5);

            return info;
        }
        """)

        await page.close()
        return page_info


class AITestGenerator:
    """AI 测试代码生成器"""

    def __init__(self, api_key: str, base_url: str = None, model: str = "deepseek-chat"):
        self.api_key = api_key
        self.base_url = base_url or "https://api.deepseek.com"
        self.model = model

    def _build_prompt(self, page_info: dict, test_scenario: str = None) -> str:
        """构建 AI 提示词"""
        scenario_desc = ""
        if test_scenario:
            scenario_desc = f"\n用户要求的测试场景：{test_scenario}\n"

        prompt = f"""你是一个资深的自动化测试工程师。请根据以下页面信息，生成 pytest-playwright 测试代码。

页面信息：
- 标题：{page_info['title']}
- URL：{page_info['url']}

页面上的按钮：
{json.dumps(page_info['buttons'], ensure_ascii=False, indent=2)}

页面上的输入框：
{json.dumps(page_info['inputs'], ensure_ascii=False, indent=2)}

页面上的链接：
{json.dumps(page_info['links'], ensure_ascii=False, indent=2)}

页面上的下拉框：
{json.dumps(page_info['selects'], ensure_ascii=False, indent=2)}
{scenario_desc}
要求：
1. 使用 pytest-playwright 的 fixture（page, context, browser 等）
2. 使用 playwright 的 expect() 进行断言
3. 使用语义化定位器（get_by_role, get_by_text, get_by_label, get_by_placeholder）
4. 添加合理的等待策略（Playwright 自动等待，但关键步骤加 page.wait_for_load_state）
5. 每个测试函数要有清晰的 docstring 说明测试目的
6. 代码要可直接运行，不要用 placeholder
7. 生成 3-5 个覆盖不同功能点的测试用例
8. 导入语句要完整
9. 使用中文注释说明每一步的操作目的

请只输出 Python 代码，不要输出其他内容。代码以 ```python 开头，```结尾。"""

        return prompt

    async def generate(self, page_info: dict, test_scenario: str = None) -> str:
        """调用 AI 生成测试代码"""
        prompt = self._build_prompt(page_info, test_scenario)

        async with httpx.AsyncClient(timeout=60) as client:
            response = await client.post(
                f"{self.base_url}/v1/chat/completions",
                headers={
                    "Authorization": f"Bearer {self.api_key}",
                    "Content-Type": "application/json"
                },
                json={
                    "model": self.model,
                    "messages": [
                        {
                            "role": "system",
                            "content": "你是一个 pytest-playwright 测试代码生成专家。只输出可直接运行的 Python 测试代码。"
                        },
                        {
                            "role": "user",
                            "content": prompt
                        }
                    ],
                    "temperature": 0.3,  # 低温度，保证代码稳定性
                    "max_tokens": 4000
                }
            )

            result = response.json()
            content = result["choices"][0]["message"]["content"]

            # 提取代码块
            if "```python" in content:
                code = content.split("```python")[1].split("```")[0]
            elif "```" in content:
                code = content.split("```")[1].split("```")[0]
            else:
                code = content

            return code.strip()


class TestRunner:
    """测试运行器"""

    @staticmethod
    def save_test(code: str, filename: str, output_dir: str = "tests/generated"):
        """保存生成的测试代码"""
        Path(output_dir).mkdir(parents=True, exist_ok=True)
        filepath = Path(output_dir) / filename
        filepath.write_text(code, encoding="utf-8")
        return str(filepath)

    @staticmethod
    def run_test(filepath: str) -> tuple[bool, str]:
        """运行测试并返回结果"""
        import subprocess
        result = subprocess.run(
            ["python", "-m", "pytest", filepath, "-v", "--tb=short"],
            capture_output=True,
            text=True,
            timeout=120
        )
        return result.returncode == 0, result.stdout + result.stderr


async def main():
    """主函数：端到端流程"""
    # 配置
    TARGET_URL = "https://www.saucedemo.com/"  # 示例：SauceDemo 电商测试站
    API_KEY = os.getenv("DEEPSEEK_API_KEY", "your-api-key-here")
    TEST_SCENARIO = "测试用户登录功能，包括成功登录和失败登录"

    print("🔍 第一步：分析页面结构...")
    async with PageAnalyzer() as analyzer:
        page_info = await analyzer.analyze(TARGET_URL)
        print(f"   发现 {len(page_info['buttons'])} 个按钮, "
              f"{len(page_info['inputs'])} 个输入框, "
              f"{len(page_info['links'])} 个链接")

    print("\n🤖 第二步：AI 生成测试代码...")
    generator = AITestGenerator(api_key=API_KEY)
    test_code = await generator.generate(page_info, TEST_SCENARIO)
    print(f"   生成了 {len(test_code)} 字符的测试代码")

    print("\n💾 第三步：保存测试文件...")
    filepath = TestRunner.save_test(
        test_code,
        "test_login_ai_generated.py",
        output_dir="tests/generated"
    )
    print(f"   保存到: {filepath}")

    print("\n🚀 第四步：运行测试...")
    success, output = TestRunner.run_test(filepath)
    if success:
        print("✅ 测试通过！")
    else:
        print("❌ 测试失败，但这是正常的——AI 也需要迭代优化")
        print(f"   输出：{output[:500]}")

    print("\n📝 生成的测试代码预览：")
    print("-" * 60)
    print(test_code[:2000])
    if len(test_code) > 2000:
        print(f"... (还有 {len(test_code) - 2000} 字符)")
    print("-" * 60)


if __name__ == "__main__":
    asyncio.run(main())

3.3 运行效果

$ python -m ai_generator.generator

🔍 第一步：分析页面结构...
   发现 3 个按钮, 2 个输入框, 5 个链接

🤖 第二步：AI 生成测试代码...
   生成了 2847 字符的测试代码

💾 第三步：保存测试文件...
   保存到: tests/generated/test_login_ai_generated.py

🚀 第四步：运行测试...
✅ 测试通过！

📝 生成的测试代码预览：
------------------------------------------------------------
import pytest
from playwright.sync_api import Page, expect


class TestUserLogin:
    """用户登录功能测试"""

    def test_successful_login(self, page: Page):
        """测试使用正确的用户名和密码登录"""
        # 打开登录页面
        page.goto("https://www.saucedemo.com/")

        # 输入用户名
        page.get_by_placeholder("Username").fill("standard_user")

        # 输入密码
        page.get_by_placeholder("Password").fill("secret_sauce")

        # 点击登录按钮
        page.get_by_role("button", name="Login").click()

        # 断言：登录成功后应该跳转到商品页面
        expect(page).to_have_url("https://www.saucedemo.com/inventory.html")
        expect(page.get_by_text("Products")).to_be_visible()
------------------------------------------------------------

---

第四章：进阶玩法——让测试更智能

4.1 Page Object 模式自动生成

如果你的项目用了 Page Object 模式（应该用！），可以让 AI 同时生成 Page 类和测试类：

class AIPageObjectGenerator(AITestGenerator):
    """AI Page Object 生成器"""

    def _build_prompt(self, page_info: dict, page_name: str) -> str:
        prompt = f"""你是一个资深的自动化测试架构师。请根据以下页面信息，生成 Page Object 类。

页面信息：
- 标题：{page_info['title']}
- URL：{page_info['url']}
- 按钮：{json.dumps(page_info['buttons'], ensure_ascii=False)}
- 输入框：{json.dumps(page_info['inputs'], ensure_ascii=False)}

要求：
1. 类名使用 PascalCase，以 Page 结尾
2. 每个可交互元素封装为一个方法
3. 方法要有清晰的 docstring
4. 使用 playwright 的 Locator API（page.locator, page.get_by_role 等）
5. 链式调用友好
6. 包含 wait_for_page_load 方法
7. 页面类名：{page_name}

请只输出 Python 代码。"""

        return prompt

4.2 批量生成测试矩阵

async def batch_generate(url_list: list[dict], generator: AITestGenerator):
    """
    批量生成测试
    url_list 格式: [{"url": "...", "scenario": "...", "page_name": "..."}]
    """
    results = []
    async with PageAnalyzer() as analyzer:
        for item in url_list:
            print(f"\n{'='*50}")
            print(f"处理: {item['url']}")

            page_info = await analyzer.analyze(item['url'])
            test_code = await generator.generate(page_info, item.get('scenario'))

            filepath = TestRunner.save_test(
                test_code,
                f"test_{item.get('page_name', 'generated')}.py"
            )
            results.append({
                "url": item['url'],
                "filepath": filepath,
                "code": test_code
            })

            # 避免 API 限流
            await asyncio.sleep(2)

    return results

4.3 测试失败自动修复

当 AI 生成的测试跑失败时，可以让 AI 根据错误信息自动修复：

class TestAutoFixer:
    """测试自动修复器"""

    def __init__(self, generator: AITestGenerator):
        self.generator = generator
        self.max_retries = 3

    async def fix_and_rerun(self, filepath: str) -> tuple[bool, str]:
        """尝试修复失败的测试"""
        for attempt in range(self.max_retries):
            success, output = TestRunner.run_test(filepath)
            if success:
                return True, output

            print(f"   第 {attempt + 1} 次尝试失败，AI 正在修复...")

            # 读取原始代码
            original_code = Path(filepath).read_text(encoding="utf-8")

            # 让 AI 根据错误信息修复代码
            fix_prompt = f"""以下 pytest-playwright 测试代码运行失败，请修复它。

原始代码：
```python
{original_code}

错误信息：
{output[-1500:]}

请输出修复后的完整代码。只输出 Python 代码。“”"

        fixed_code = await self.generator.generate(
            {"title": "fix", "url": "", "buttons": [], "inputs": [], "links": [], "selects": []},
            fix_prompt
        )

        # 保存修复后的代码
        Path(filepath).write_text(fixed_code, encoding="utf-8")

    return False, f"经过 {self.max_retries} 次修复仍然失败"

### 4.4 视觉回归测试

Playwright 内置了截图对比功能，结合 AI 可以做智能视觉回归：

```python
def test_visual_regression(page: Page):
    """视觉回归测试：对比页面截图"""
    page.goto("https://example.com")

    # 截取当前页面
    screenshot = page.screenshot()

    # 与基线图片对比
    # pytest-playwright 内置支持 to_have_screenshot()
    expect(page).to_have_screenshot("homepage.png", max_diff_pixel_ratio=0.01)

AI 可以根据页面变化自动更新基线图片，并生成变更报告。

---

第五章：实战案例——测试一个真实电商网站

5.1 目标网站

我们用 SauceDemo（https://www.saucedemo.com/）作为示例。这是一个专门为测试设计的电商网站。

5.2 AI 生成的完整测试

"""
SauceDemo 电商网站自动化测试
由 AI 自动生成，人工审核并优化
"""
import pytest
from playwright.sync_api import Page, expect


# ==================== Fixtures ====================

@pytest.fixture
def logged_in_page(page: Page):
    """已登录状态的页面 fixture"""
    page.goto("https://www.saucedemo.com/")
    page.get_by_placeholder("Username").fill("standard_user")
    page.get_by_placeholder("Password").fill("secret_sauce")
    page.get_by_role("button", name="Login").click()
    expect(page).to_have_url("https://www.saucedemo.com/inventory.html")
    return page


# ==================== 登录测试 ====================

class TestLogin:
    """登录功能测试"""

    def test_login_success(self, page: Page):
        """验证正确凭证可以成功登录"""
        page.goto("https://www.saucedemo.com/")

        page.get_by_placeholder("Username").fill("standard_user")
        page.get_by_placeholder("Password").fill("secret_sauce")
        page.get_by_role("button", name="Login").click()

        expect(page).to_have_url("https://www.saucedemo.com/inventory.html")
        expect(page.get_by_text("Products")).to_be_visible()

    def test_login_wrong_password(self, page: Page):
        """验证错误密码时显示错误提示"""
        page.goto("https://www.saucedemo.com/")

        page.get_by_placeholder("Username").fill("standard_user")
        page.get_by_placeholder("Password").fill("wrong_password")
        page.get_by_role("button", name="Login").click()

        # 断言错误提示出现
        error_msg = page.locator("[data-test='error']")
        expect(error_msg).to_be_visible()
        expect(error_msg).to_contain_text("Username and password do not match")

    def test_login_locked_user(self, page: Page):
        """验证被锁定的用户无法登录"""
        page.goto("https://www.saucedemo.com/")

        page.get_by_placeholder("Username").fill("locked_out_user")
        page.get_by_placeholder("Password").fill("secret_sauce")
        page.get_by_role("button", name="Login").click()

        error_msg = page.locator("[data-test='error']")
        expect(error_msg).to_be_visible()
        expect(error_msg).to_contain_text("locked out")


# ==================== 商品页面测试 ====================

class TestProducts:
    """商品页面测试"""

    def test_products_page_loads(self, logged_in_page: Page):
        """验证商品页面正确加载"""
        page = logged_in_page

        # 验证页面标题
        expect(page.get_by_text("Products")).to_be_visible()

        # 验证商品列表不为空
        items = page.locator(".inventory_item")
        expect(items).to_have_count(6)  # SauceDemo 有 6 个商品

    def test_sort_products_by_price(self, logged_in_page: Page):
        """验证按价格排序功能"""
        page = logged_in_page

        # 选择按价格从低到高排序
        page.get_by_role("combobox").select_option("lohi")

        # 验证第一个商品价格最低
        first_price = page.locator(".inventory_item_price").first
        expect(first_price).to_have_text("$7.99")

    def test_add_to_cart(self, logged_in_page: Page):
        """验证添加商品到购物车"""
        page = logged_in_page

        # 添加第一个商品
        page.locator(".inventory_item").first.get_by_role("button", name="Add to cart").click()

        # 验证购物车图标显示数量 1
        badge = page.locator(".shopping_cart_badge")
        expect(badge).to_have_text("1")

    def test_remove_from_cart(self, logged_in_page: Page):
        """验证从购物车移除商品"""
        page = logged_in_page

        # 先添加
        page.locator(".inventory_item").first.get_by_role("button", name="Add to cart").click()
        expect(page.locator(".shopping_cart_badge")).to_have_text("1")

        # 再移除
        page.locator(".inventory_item").first.get_by_role("button", name="Remove").click()

        # 验证购物车为空
        expect(page.locator(".shopping_cart_badge")).not_to_be_visible()


# ==================== 购物车测试 ====================

class TestCart:
    """购物车功能测试"""

    def test_cart_page_shows_items(self, logged_in_page: Page):
        """验证购物车页面显示已添加的商品"""
        page = logged_in_page

        # 添加一个商品
        page.locator(".inventory_item").first.get_by_role("button", name="Add to cart").click()

        # 进入购物车
        page.locator(".shopping_cart_link").click()
        expect(page).to_have_url("https://www.saucedemo.com/cart.html")

        # 验证购物车有商品
        items = page.locator(".cart_item")
        expect(items).to_have_count(1)

    def test_continue_shopping(self, logged_in_page: Page):
        """验证继续购物按钮"""
        page = logged_in_page

        page.locator(".shopping_cart_link").click()
        page.get_by_role("button", name="Continue Shopping").click()

        expect(page).to_have_url("https://www.saucedemo.com/inventory.html")

    def test_checkout_flow(self, logged_in_page: Page):
        """验证结账流程"""
        page = logged_in_page

        # 添加商品
        page.locator(".inventory_item").first.get_by_role("button", name="Add to cart").click()

        # 进入购物车并结账
        page.locator(".shopping_cart_link").click()
        page.get_by_role("button", name="Checkout").click()

        # 填写结账信息
        expect(page).to_have_url("https://www.saucedemo.com/checkout-step-one.html")
        page.get_by_placeholder("First Name").fill("Test")
        page.get_by_placeholder("Last Name").fill("User")
        page.get_by_placeholder("Zip/Postal Code").fill("12345")
        page.get_by_role("button", name="Continue").click()

        # 验证进入结账确认页面
        expect(page).to_have_url("https://www.saucedemo.com/checkout-step-two.html")
        expect(page.get_by_text("Checkout: Overview")).to_be_visible()

        # 完成结账
        page.get_by_role("button", name="Finish").click()
        expect(page).to_have_url("https://www.saucedemo.com/checkout-complete.html")
        expect(page.get_by_text("Thank you for your order!")).to_be_visible()

---

第六章：踩坑指南——AI 不是万能的

6.1 常见问题及解决

问题 1：AI 生成的定位器找不到元素

# ❌ AI 可能生成的脆弱定位器
page.locator("#app > div > main > div > div:nth-child(3) > button").click()

# ✅ 应该使用语义化定位器
page.get_by_role("button", name="Add to cart").click()

解决方法： 在 prompt 中强调使用语义化定位器，或者在生成后让 AI 做一次代码审查。

问题 2：AI 不理解动态内容

# ❌ AI 可能写死文本内容
expect(page.get_by_text("6 items")).to_be_visible()

# ✅ 应该使用更灵活的断言
expect(page.locator(".inventory_item")).not_to_have_count(0)

问题 3：等待不够导致 flaky 测试

# ❌ 可能出现的竞态条件
page.get_by_role("button", name="Submit").click()
expect(page.get_by_text("Success")).to_be_visible()  # 可能太快

# ✅ 加上明确的等待
page.get_by_role("button", name="Submit").click()
page.wait_for_load_state("networkidle")
expect(page.get_by_text("Success")).to_be_visible()

6.2 AI 测试生成的局限性

1. 复杂业务逻辑： AI 不理解你的业务规则，比如"VIP 用户打八折"
2. 跨页面流程： 多步骤流程需要人工规划测试路径
3. 测试数据管理： AI 不会帮你设计测试数据策略
4. 环境配置： 不同环境的 URL、账号等需要人工配置
5. 性能测试： AI 生成的是功能测试，不是性能测试

6.3 最佳实践

# 1. AI 生成 + 人工审核 = 最佳组合
# 不要盲目信任 AI 生成的代码，一定要 review

# 2. 建立测试模板库
# 常见场景（登录、搜索、表单提交）保存模板，减少 AI 调用

# 3. 分层测试策略
# - 冒烟测试：AI 自动生成，覆盖主要路径
# - 回归测试：人工编写，覆盖边界条件
# - 探索性测试：人工执行，发现未知问题

# 4. 持续集成
# 把 AI 生成的测试加入 CI/CD 流水线
# pytest tests/generated/ --alluredir=allure-results

---

第七章：与传统方案的对比

对比维度	纯 Selenium	Playwright 手写	pytest-playwright + AI
单个用例编写时间	30-60 分钟	10-20 分钟	10-30 秒
学习曲线	陡峭	中等	低（会写 prompt 就行）
维护成本	高（flaky 测试多）	中等	低（自动修复）
代码质量	参差不齐	取决于开发者	AI 保证基本质量
覆盖率	低	中等	高（快速生成大量用例）
适合场景	遗留项目	中小型项目	快速迭代的项目

---

总结：测试工程师的未来在哪里？

写到这里，可能有些测试工程师开始焦虑了：AI 都能写测试了，我是不是要失业了？

答案是：不会。但你的工作方式会彻底改变。

以前，测试工程师的价值体现在"写测试用例"。现在，AI 可以写测试用例了，但测试工程师的价值体现在：

1. 测试策略设计： AI 不知道应该测什么，但你知道
2. 质量把关： AI 生成的代码需要你来审核和优化
3. 探索性测试： AI 只能测试已知路径，你才能发现未知的 bug
4. 测试架构： 怎么组织测试代码、怎么管理测试数据、怎么设计 CI/CD 流水线
5. 业务理解： 这是 AI 永远替代不了的

所以，与其担心被 AI 替代，不如学会驾驭 AI。

用 pytest-playwright + AI 的组合，你可以：

• 把写测试的时间从 30 分钟压缩到 30 秒
• 把测试覆盖率从 30% 提升到 80%
• 把维护成本降低 50%
• 把更多时间花在真正有价值的事情上

最后送大家一句话：

“未来的测试工程师不是不写代码，而是不写重复的代码。”

祝大家测试愉快，Bug 远离。

---

如果觉得本文对你有帮助，欢迎点赞、收藏、关注三连！你的支持是我持续创作的动力。

有问题欢迎在评论区讨论，我会尽量回复每一条评论。