关注 霍格沃兹测试学院公众号，回复「资料」, 领取人工智能测试开发技术合集

当我们为现代Web应用编写自动化测试时，测试用例的数量通常会快速增长。一个中等规模的项目可能就有数百个测试用例，完整执行一遍可能需要几十分钟甚至几小时。如何高效组织这些测试的执行，直接影响到开发团队的迭代速度和反馈周期。

Playwright作为新一代的浏览器自动化工具，不仅提供了强大的API，还内置了灵活的执行策略支持。本文将深入探讨三种核心测试执行模式：顺序执行、并行执行和分布式测试，帮助您根据项目需求选择最佳方案。

一、顺序测试执行：简单可靠的基础策略

1.1 何时使用顺序执行

顺序执行是最直接的测试方式——一个接一个地运行测试用例。这种策略在以下场景特别适用：

• 测试用例之间存在依赖关系

• 需要精确控制执行顺序（如：登录→操作→验证→登出）

• 调试阶段，需要清晰的错误追踪

• 资源受限的环境

1.2 配置顺序执行

Playwright Test默认使用顺序执行。但我们可以通过配置文件明确指定：

// playwright.config.js const { defineConfig } = require('@playwright/test'); module.exports = defineConfig({ workers: 1, // 关键配置：worker数量为1表示顺序执行 fullyParallel: false, // 其他配置... use: { headless: true, viewport: { width: 1280, height: 720 }, }, });

1.3 处理测试间依赖

在顺序执行中，我们可以利用Playwright的Fixture机制处理依赖：

// tests/auth-flow.spec.ts import { test } from'@playwright/test'; // 创建共享的认证状态 const authFile = 'playwright/.auth/user.json'; test.describe.configure({ mode: 'serial' }); // 声明测试需要顺序执行 let pageContext; // 共享的上下文 test('用户登录', async ({ page }) => { await page.goto('/login'); await page.fill('#username', 'testuser'); await page.fill('#password', 'password123'); await page.click('button[type="submit"]'); // 保存认证状态 await page.context().storageState({ path: authFile }); pageContext = page.context(); }); test('访问受限页面', async () => { // 复用已认证的上下文 const page = await pageContext.newPage(); await page.goto('/dashboard'); await expect(page.locator('.welcome-message')).toContainText('testuser'); });

二、并行测试执行：大幅缩短执行时间

2.1 并行执行的优势

当测试用例相互独立时，并行执行能显著提升效率：

• 利用多核CPU，同时运行多个测试

• 执行时间与workers数量近似成反比

• 适合CI/CD流水线，快速获得反馈

2.2 配置并行执行

// playwright.config.js module.exports = defineConfig({ // 根据CPU核心数自动分配workers workers: process.env.CI ? 4 : undefined, // CI环境使用4个worker // 或者指定具体数量 // workers: 4, fullyParallel: true, // 所有测试文件并行执行 // 控制最大失败比例，避免大量重试 maxFailures: process.env.CI ? 5 : undefined, });

2.3 确保测试隔离性

并行执行要求测试完全独立。以下是常见的隔离问题和解决方案：

// tests/parallel-demo.spec.ts import { test, expect } from'@playwright/test'; // ❌ 错误示例：使用共享状态 // let sharedCounter = 0; // 这会在并行执行时导致竞态条件 test.describe('并行安全的测试套件', () => { // ✅ 正确做法：每个测试使用独立数据 test('测试1：独立用户操作', async ({ page }) => { // 使用唯一的测试数据 const uniqueUsername = `user_${Date.now()}_${Math.random()}`; await page.goto('/register'); await page.fill('#username', uniqueUsername); // ... 其他操作 }); test('测试2：独立订单流程', async ({ page }) => { // 每个测试创建独立的测试数据 const orderId = `ORDER_${Date.now()}`; // ... 使用独立订单ID进行操作 }); }); // ✅ 使用测试隔离的数据库或API test.beforeEach(async ({ request }) => { // 每个测试前重置测试数据 await request.post('/test-api/reset', { data: { testId: test.info().testId } }); });

2.4 并行执行优化技巧

// playwright.config.js module.exports = defineConfig({ workers: 4, // 优化并行执行 retries: 1, // 失败重试次数 // 设置超时控制 timeout: 30000, // 按测试文件分配，避免内存溢出 use: { // 每个worker的最大测试数 trace: 'on-first-retry', screenshot: 'only-on-failure', }, // 项目分组：将相关测试分到同一组并行执行 projects: [ { name: 'chromium', use: { browserName: 'chromium' }, }, { name: 'firefox', use: { browserName: 'firefox' }, }, ], });

三、分布式测试：大规模测试的解决方案

3.1 什么是分布式测试

当测试套件非常庞大（数千个测试用例）时，单机并行受限于硬件资源。分布式测试将测试分发到多台机器上执行，实现真正的横向扩展。

3.2 基于Shard的测试分发

Playwright原生支持分片（sharding）执行：

# 将测试分成4个分片，执行第1个分片 npx playwright test --shard=1/4 # 在CI中通常这样配置 npx playwright test --shard=$SHARD_INDEX/$SHARD_TOTAL

在CI/CD流水线中配置：

# .github/workflows/playwright.yml name:PlaywrightTests on:[push] jobs: test: timeout-minutes:60 runs-on:ubuntu-latest strategy: fail-fast:false matrix: shard:[1,2,3,4]# 4个分片 steps: -uses:actions/checkout@v3 -uses:actions/setup-node@v3 -run:npmci -run:npxplaywrightinstall--with-deps # 执行分配的分片 -run:npxplaywrighttest--shard=${{matrix.shard}}/${{strategy.matrix.shard.length}} # 上传测试结果 -uses:actions/upload-artifact@v3 if:always() with: name:test-results-shard-${{matrix.shard}} path:test-results/

3.3 使用测试编排工具

对于更复杂的分布式场景，可以使用专门的测试编排工具：

// 使用Playwright Test Runner API自定义分发逻辑 const { chromium } = require('playwright'); const { exec } = require('child_process'); const os = require('os'); asyncfunction distributeTests() { const testFiles = await getTestFiles(); // 获取所有测试文件 const workers = getAvailableWorkers(); // 获取可用worker列表 // 简单的负载均衡算法 const chunks = chunkArray(testFiles, workers.length); const promises = workers.map((worker, index) => { return runTestsOnWorker(worker, chunks[index]); }); awaitPromise.all(promises); } // 根据测试历史数据智能分发 function smartDistribution(testFiles, historicalData) { return testFiles.sort((a, b) => { // 根据历史执行时间排序，平衡各worker负载 const timeA = historicalData[a]?.duration || 30; const timeB = historicalData[b]?.duration || 30; return timeB - timeA; }); }

3.4 分布式测试的最佳实践

1. 测试数据管理

// 使用唯一标识避免冲突 function generateTestData(workerId, testId) { return { userId: `testuser_${workerId}_${testId}`, email: `test_${workerId}_${Date.now()}@example.com`, // 其他测试数据... }; }

1. 结果聚合

# 在各分片执行后聚合结果 npx playwright merge-reports ./shard-1-results ./shard-2-results ./shard-3-results

1. 资源清理

// 每个worker执行完成后清理资源 test.afterAll(async ({ request }, testInfo) => { if (testInfo.config.workerIndex === 0) { // 只有第一个worker执行全局清理 await request.post('/test-api/cleanup-all'); } });

四、混合策略与动态调整

在实际项目中，我们经常需要混合使用多种策略：

// 动态配置示例 module.exports = defineConfig({ // 基础配置 workers: process.env.TEST_WORKERS || '50%', // 可动态调整 // 项目级别的并行控制 projects: [ { name: 'critical', testMatch: '**/*.critical.spec.ts', workers: 1, // 关键测试顺序执行，确保稳定性 }, { name: 'integration', testMatch: '**/*.integration.spec.ts', workers: 2, // 集成测试中等并行度 }, { name: 'ui', testMatch: '**/*.ui.spec.ts', workers: 4, // UI测试高并行度 fullyParallel: true, }, ], // 根据环境动态调整 ...(process.env.CI && { retries: 2, timeout: 60000, reporter: [ ['html', { outputFolder: 'playwright-report' }], ['github'], // CI专用reporter ], }), });

五、性能监控与优化

5.1 监控测试执行效率

// 收集测试执行指标 const fs = require('fs'); const path = require('path'); test.afterEach(async ({}, testInfo) => { const metrics = { testId: testInfo.title, duration: testInfo.duration, workerIndex: testInfo.workerIndex, startTime: testInfo.startTime.toISOString(), status: testInfo.status, }; // 保存到文件供分析使用 const logPath = path.join('test-metrics', `worker-${testInfo.workerIndex}.json`); fs.appendFileSync(logPath, JSON.stringify(metrics) + '\n'); });

5.2 基于历史数据的优化

// 根据历史执行时间动态调整执行策略 function createDynamicConfig(historicalData) { const slowTests = Object.entries(historicalData) .filter(([_, data]) => data.duration > 10000) // 超过10秒的测试 .map(([test]) => test); const fastTests = Object.entries(historicalData) .filter(([_, data]) => data.duration <= 10000) .map(([test]) => test); return { projects: [ { name: 'slow-tests', testMatch: slowTests, workers: 1, // 慢测试顺序执行 timeout: 120000, }, { name: 'fast-tests', testMatch: fastTests, workers: '100%', // 快测试高度并行 fullyParallel: true, }, ], }; }

六、策略选择指南

选择标准矩阵

决策流程图

开始 ↓ 分析测试特性 ├── 有测试间依赖？ → 采用顺序执行 ├── 测试完全独立？ → 评估测试规模 │ ├── 小型(<100) → 单机并行 │ ├── 中型(100-1000) → 高度并行+分片 │ └── 大型(>1000) → 分布式执行 └── 混合特性？ → 项目分组+混合策略 ↓ 监控执行效果 ↓ 根据历史数据优化策略

选择合适的Playwright测试执行策略需要综合考虑测试特性、项目规模和可用资源。从简单的顺序执行到复杂的分布式测试，每种策略都有其适用场景。

关键要点总结：

1. 顺序执行适用于调试和存在依赖的测试场景

2. 并行执行能显著提升独立测试的执行效率

3. 分布式测试是大型测试套件的终极解决方案

4. 混合策略在实际项目中往往最有效

5. 持续监控和优化是保持测试效率的关键

建议团队从并行执行开始，随着测试规模增长逐步引入更复杂的策略。同时，建立测试执行指标的监控体系，基于数据不断优化执行策略，才能在测试覆盖率和执行效率之间找到最佳平衡点。

记住，没有"一刀切"的最佳策略。最有效的执行策略总是基于对自身测试套件的深入理解和持续优化。

推荐学习

自动化智能体与测试用例生成课程，限时免费，机会难得。扫码报名，参与直播，希望您在这场课程中收获满满，开启智能自动化测试的新篇章！