HarmonyOS开发：E2E测试——端到端测试

📌 核心要点：E2E测试模拟真实用户从打开App到完成目标的完整流程，跨页面、跨状态的验证确保业务链路端到端畅通，稳定性保障是最大挑战。

背景与动机

单元测试验证函数对不对，UI测试验证页面能不能点，但用户不关心这些。用户关心的是：我能不能从首页搜到商品、加入购物车、下单付款、收到订单？

这就是端到端（End-to-End）测试要验证的事——完整的用户旅程。

你每个页面单独测都没问题，但串起来可能就出事了。首页跳转传的参数，详情页没接住；购物车加的商品，结算页显示不出来；支付完成后，订单页还是空的。这些问题只有跑完整流程才能发现。

E2E测试和普通UI测试的区别是什么？普通UI测试关注"一个页面、一个操作"，E2E测试关注"一条链路、一个目标"。E2E测试的代码更长、执行更慢、更容易受环境影响，但它验证的是用户真正关心的东西——业务能不能跑通。

核心原理

E2E测试的层次

graph TB
    A[测试金字塔] --> B[单元测试<br/>数量多/速度快/范围小]
    A --> C[集成测试<br/>数量中/速度中/范围中]
    A --> D[E2E测试<br/>数量少/速度慢/范围大]
    
    D --> D1[核心业务流程]
    D --> D2[关键用户路径]
    D --> D3[高价值场景]
    
    D1 --> D1a["注册→登录→使用"]
    D1 --> D1b["搜索→浏览→购买"]
    D1 --> D1c["下单→支付→查看订单"]
    
    classDef unit fill:#67C23A,stroke:#3E9B2B,color:#fff
    classDef integration fill:#E6A23C,stroke:#B07D2B,color:#fff
    classDef e2e fill:#F56C6C,stroke:#C94A4A,color:#fff
    classDef flow fill:#9B59B6,stroke:#7D3C98,color:#fff
    
    class B unit
    class C integration
    class D e2e
    class D1,D2,D3,D1a,D1b,D1c flow

E2E测试的核心挑战

flowchart TD
    A[E2E测试挑战] --> B[稳定性]
    A --> C[执行速度]
    A --> D[环境依赖]
    A --> E[数据管理]
    
    B --> B1["网络波动"]
    B --> B2["时序问题"]
    B --> B3["设备差异"]
    
    C --> C1["等待时间累积"]
    C --> C2["长链路执行慢"]
    
    D --> D1["依赖后端服务"]
    D --> D2["依赖设备状态"]
    D --> D3["依赖系统版本"]
    
    E --> E1["测试数据隔离"]
    E --> E2["数据状态重置"]
    E --> E3["并发数据冲突"]
    
    classDef root fill:#4A90D9,stroke:#2C5F8A,color:#fff
    classDef challenge fill:#F56C6C,stroke:#C94A4A,color:#fff
    classDef detail fill:#E6A23C,stroke:#B07D2B,color:#fff
    
    class A root
    class B,C,D,E challenge
    class B1,B2,B3,C1,C2,D1,D2,D3,E1,E2,E3 detail

提高E2E稳定性的策略

E2E测试最怕的就是"时灵时不灵"。今天跑过了，明天同样的代码就挂了——不是代码有bug，是环境变了。解决这个问题的核心策略：

1. 智能等待：不要用固定sleep，用条件等待（等到目标组件出现再继续）
2. 重试机制：单次失败自动重试，排除偶发因素
3. 数据隔离：每个测试用例使用独立的测试数据，互不干扰
4. 环境快照：测试前重置环境到已知状态

代码实战

基础用法：跨页面流程测试

// 469_e2e_test_basic.ets
import { Driver, ON } from '@ohos.UiTest';

// 基础E2E测试：搜索→详情→返回
export default async function basicE2ETest() {
  const driver = Driver.create();
  
  // ===== 第1步：在首页搜索商品 =====
  console.info('步骤1: 搜索商品');
  
  // 点击搜索入口
  const searchBox = driver.findComponent(ON.id('search_box'));
  if (searchBox === null) {
    throw new Error('找不到搜索入口');
  }
  searchBox.click();
  
  // 等待搜索页面加载
  driver.assertComponentExistence(ON.id('search_page'), 3000);
  
  // 输入搜索关键词
  const searchInput = driver.findComponent(ON.id('search_input'));
  searchInput?.inputText('蓝牙耳机');
  driver.pressKey(KeyCode.ENTER);
  
  // 等待搜索结果
  driver.assertComponentExistence(ON.id('search_result_list'), 5000);
  console.info('✅ 搜索完成');
  
  // ===== 第2步：进入商品详情 =====
  console.info('步骤2: 进入商品详情');
  
  const firstResult = driver.findComponent(ON.id('search_result_0'));
  if (firstResult === null) {
    throw new Error('搜索结果为空');
  }
  firstResult.click();
  
  // 等待详情页加载
  driver.assertComponentExistence(ON.id('product_detail_page'), 5000);
  console.info('✅ 进入详情页');
  
  // ===== 第3步：验证详情页内容 =====
  console.info('步骤3: 验证详情页');
  
  const productName = driver.findComponent(ON.id('product_name'));
  if (productName !== null) {
    const name = productName.getText();
    console.info(`商品名称: ${name}`);
    // 验证名称包含搜索关键词
    if (!name.includes('蓝牙') && !name.includes('耳机')) {
      console.warn('⚠️ 商品名称与搜索关键词不匹配');
    }
  }
  
  const productPrice = driver.findComponent(ON.id('product_price'));
  if (productPrice !== null) {
    console.info(`商品价格: ${productPrice.getText()}`);
  }
  console.info('✅ 详情页验证完成');
  
  // ===== 第4步：返回搜索结果 =====
  console.info('步骤4: 返回搜索结果');
  
  driver.pressKey(KeyCode.BACK);
  driver.assertComponentExistence(ON.id('search_result_list'), 3000);
  console.info('✅ 返回搜索结果');
  
  console.info('🎉 E2E测试完成: 搜索→详情→返回');
}

进阶用法：带重试和数据管理的E2E测试

// 469_e2e_test_advanced.ets
import { Driver, ON } from '@ohos.UiTest';

// E2E测试工具类
class E2ETestRunner {
  private driver: Driver;
  private maxRetries: number;
  private retryDelay: number;
  private testData: Map<string, string>;
  
  constructor(options?: { maxRetries?: number; retryDelay?: number }) {
    this.driver = Driver.create();
    this.maxRetries = options?.maxRetries ?? 2;
    this.retryDelay = options?.retryDelay ?? 1000;
    this.testData = new Map();
    
    // 初始化测试数据
    this.initTestData();
  }
  
  // 初始化测试数据
  private initTestData(): void {
    this.testData.set('username', 'e2e_test_user');
    this.testData.set('password', 'Test123456');
    this.testData.set('search_keyword', '蓝牙耳机');
    this.testData.set('product_name', '华为FreeBuds Pro');
  }
  
  // 带重试的测试执行
  async runWithRetry(testFn: () => Promise<void>, testName: string): Promise<boolean> {
    let lastError: Error | null = null;
    
    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
      try {
        if (attempt > 0) {
          console.info(`🔄 重试 ${testName} (第${attempt}次)`);
          await this.sleep(this.retryDelay);
          // 重试前重置到初始状态
          await this.resetToHomePage();
        }
        
        await testFn();
        console.info(`✅ ${testName} 通过`);
        return true;
      } catch (error) {
        lastError = error as Error;
        console.warn(`⚠️ ${testName} 第${attempt + 1}次失败: ${lastError.message}`);
      }
    }
    
    console.error(`❌ ${testName} 最终失败 (重试${this.maxRetries}次后): ${lastError?.message}`);
    // 截图保存失败现场
    this.driver.captureScreen(`/data/local/tmp/e2e_fail_${testName}_${Date.now()}.png`);
    return false;
  }
  
  // 安全操作：带等待和空值检查
  async safeClick(selector: ON, timeout: number = 5000): Promise<void> {
    const component = await this.waitForComponent(selector, timeout);
    component.click();
  }
  
  // 安全输入
  async safeInput(selector: ON, text: string, timeout: number = 5000): Promise<void> {
    const component = await this.waitForComponent(selector, timeout);
    component.inputText(text);
  }
  
  // 等待组件出现
  private async waitForComponent(selector: ON, timeout: number): Promise<Component> {
    const startTime = Date.now();
    
    while (Date.now() - startTime < timeout) {
      const component = this.driver.findComponent(selector);
      if (component !== null) {
        return component;
      }
      await this.sleep(500);
    }
    
    throw new Error(`等待组件超时: ${selector}`);
  }
  
  // 重置到首页
  private async resetToHomePage(): Promise<void> {
    // 连按返回键直到回到首页
    for (let i = 0; i < 5; i++) {
      const homeIndicator = this.driver.findComponent(ON.id('home_page'));
      if (homeIndicator !== null) {
        break;
      }
      this.driver.pressKey(KeyCode.BACK);
      await this.sleep(300);
    }
    
    // 点击首页Tab确保回到首页
    const homeTab = this.driver.findComponent(ON.id('tab_home'));
    homeTab?.click();
    await this.sleep(500);
  }
  
  // 获取测试数据
  getData(key: string): string {
    return this.testData.get(key) ?? '';
  }
  
  private sleep(ms: number): Promise<void> {
    return new Promise(resolve => setTimeout(resolve, ms));
  }
}

// 购物流程E2E测试
async function shoppingFlowE2E(): Promise<void> {
  const runner = new E2ETestRunner({ maxRetries: 2, retryDelay: 2000 });
  const driver = Driver.create();
  
  await runner.runWithRetry(async () => {
    // ===== 步骤1：搜索商品 =====
    await runner.safeClick(ON.id('search_box'));
    driver.assertComponentExistence(ON.id('search_page'), 3000);
    await runner.safeInput(ON.id('search_input'), runner.getData('search_keyword'));
    driver.pressKey(KeyCode.ENTER);
    driver.assertComponentExistence(ON.id('search_result_list'), 8000);
    
    // ===== 步骤2：选择商品 =====
    await runner.safeClick(ON.id('search_result_0'));
    driver.assertComponentExistence(ON.id('product_detail_page'), 5000);
    
    // ===== 步骤3：选择规格并加入购物车 =====
    await runner.safeClick(ON.text('黑色'));
    await runner.safeClick(ON.id('add_to_cart'));
    driver.assertComponentExistence(ON.text('已加入购物车'), 3000);
    
    // ===== 步骤4：进入购物车 =====
    await runner.safeClick(ON.id('tab_cart'));
    driver.assertComponentExistence(ON.id('cart_page'), 3000);
    
    // 验证购物车中有商品
    const cartItems = driver.findComponents(ON.type('ListItem'));
    if (cartItems.length === 0) {
      throw new Error('购物车为空，加入购物车可能失败');
    }
    
    // ===== 步骤5：结算 =====
    await runner.safeClick(ON.id('cart_item_checkbox'));
    await runner.safeClick(ON.text('结算'));
    driver.assertComponentExistence(ON.id('checkout_page'), 5000);
    
    // ===== 步骤6：确认订单 =====
    await runner.safeClick(ON.id('confirm_order'));
    driver.assertComponentExistence(ON.text('订单提交成功'), 10000);
    
    console.info('🎉 购物流程E2E测试完成');
  }, '购物流程');
}

完整示例：多链路E2E测试套件

// 469_e2e_test_full.ets
import { Driver, ON } from '@ohos.UiTest';

// E2E测试套件
class E2ETestSuite {
  private runner: E2ETestRunner;
  private results: Array<{
    flowName: string;
    passed: boolean;
    duration: number;
    error?: string;
  }>;
  
  constructor() {
    this.runner = new E2ETestRunner({ maxRetries: 2, retryDelay: 2000 });
    this.results = [];
  }
  
  // 用户旅程1：新用户注册→登录→首次使用
  async testNewUserJourney(): Promise<void> {
    const startTime = Date.now();
    
    const passed = await this.runner.runWithRetry(async () => {
      const driver = Driver.create();
      
      // 注册
      await this.runner.safeClick(ON.text('注册'));
      driver.assertComponentExistence(ON.id('register_page'), 3000);
      
      await this.runner.safeInput(ON.id('reg_username'), `test_${Date.now()}`);
      await this.runner.safeInput(ON.id('reg_phone'), '13800138000');
      await this.runner.safeInput(ON.id('reg_password'), 'Test123456');
      await this.runner.safeInput(ON.id('reg_confirm_password'), 'Test123456');
      await this.runner.safeClick(ON.id('agree_checkbox'));
      await this.runner.safeClick(ON.id('register_btn'));
      
      // 验证注册成功
      driver.assertComponentExistence(ON.text('注册成功'), 8000);
      
      // 首次使用引导
      driver.assertComponentExistence(ON.id('onboarding_page'), 5000);
      await this.runner.safeClick(ON.text('跳过'));
      
      // 验证进入首页
      driver.assertComponentExistence(ON.id('home_page'), 5000);
    }, '新用户注册流程');
    
    this.results.push({
      flowName: '新用户注册→登录→首次使用',
      passed,
      duration: Date.now() - startTime,
    });
  }
  
  // 用户旅程2：搜索→浏览→收藏→购买
  async testBrowseAndBuyJourney(): Promise<void> {
    const startTime = Date.now();
    
    const passed = await this.runner.runWithRetry(async () => {
      const driver = Driver.create();
      
      // 搜索
      await this.runner.safeClick(ON.id('search_box'));
      driver.assertComponentExistence(ON.id('search_page'), 3000);
      await this.runner.safeInput(ON.id('search_input'), '蓝牙耳机');
      driver.pressKey(KeyCode.ENTER);
      driver.assertComponentExistence(ON.id('search_result_list'), 8000);
      
      // 浏览商品
      await this.runner.safeClick(ON.id('search_result_0'));
      driver.assertComponentExistence(ON.id('product_detail_page'), 5000);
      
      // 收藏
      await this.runner.safeClick(ON.id('favorite_btn'));
      driver.assertComponentExistence(ON.text('已收藏'), 3000);
      
      // 加入购物车
      await this.runner.safeClick(ON.id('add_to_cart'));
      driver.assertComponentExistence(ON.text('已加入购物车'), 3000);
      
      // 购买
      await this.runner.safeClick(ON.id('buy_now'));
      driver.assertComponentExistence(ON.id('checkout_page'), 5000);
      await this.runner.safeClick(ON.id('confirm_order'));
      driver.assertComponentExistence(ON.text('订单提交成功'), 10000);
    }, '搜索→浏览→收藏→购买');
    
    this.results.push({
      flowName: '搜索→浏览→收藏→购买',
      passed,
      duration: Date.now() - startTime,
    });
  }
  
  // 用户旅程3：订单管理→评价→售后
  async testOrderManagementJourney(): Promise<void> {
    const startTime = Date.now();
    
    const passed = await this.runner.runWithRetry(async () => {
      const driver = Driver.create();
      
      // 进入订单列表
      await this.runner.safeClick(ON.id('tab_profile'));
      driver.assertComponentExistence(ON.id('profile_page'), 3000);
      await this.runner.safeClick(ON.text('我的订单'));
      driver.assertComponentExistence(ON.id('order_list_page'), 5000);
      
      // 查看订单详情
      await this.runner.safeClick(ON.id('order_item_0'));
      driver.assertComponentExistence(ON.id('order_detail_page'), 5000);
      
      // 确认收货
      await this.runner.safeClick(ON.text('确认收货'));
      driver.assertComponentExistence(ON.text('已确认收货'), 3000);
      
      // 评价
      await this.runner.safeClick(ON.text('去评价'));
      driver.assertComponentExistence(ON.id('review_page'), 3000);
      await this.runner.safeInput(ON.id('review_content'), '商品不错，好评！');
      await this.runner.safeClick(ON.id('submit_review'));
      driver.assertComponentExistence(ON.text('评价成功'), 5000);
    }, '订单管理→评价→售后');
    
    this.results.push({
      flowName: '订单管理→评价→售后',
      passed,
      duration: Date.now() - startTime,
    });
  }
  
  // 用户旅程4：设置→个人信息修改→退出登录
  async testSettingsJourney(): Promise<void> {
    const startTime = Date.now();
    
    const passed = await this.runner.runWithRetry(async () => {
      const driver = Driver.create();
      
      // 进入设置
      await this.runner.safeClick(ON.id('tab_profile'));
      await this.runner.safeClick(ON.text('设置'));
      driver.assertComponentExistence(ON.id('settings_page'), 3000);
      
      // 修改头像（简化：只验证能进入编辑页）
      await this.runner.safeClick(ON.id('avatar_edit'));
      driver.assertComponentExistence(ON.id('avatar_edit_page'), 3000);
      driver.pressKey(KeyCode.BACK);
      
      // 修改昵称
      await this.runner.safeClick(ON.id('nickname_edit'));
      driver.assertComponentExistence(ON.id('nickname_input'), 3000);
      await this.runner.safeInput(ON.id('nickname_input'), '测试用户');
      await this.runner.safeClick(ON.text('保存'));
      driver.assertComponentExistence(ON.text('保存成功'), 3000);
      
      // 退出登录
      await this.runner.safeClick(ON.text('退出登录'));
      driver.assertComponentExistence(ON.text('确认退出'), 3000);
      await this.runner.safeClick(ON.text('确认'));
      driver.assertComponentExistence(ON.id('login_page'), 5000);
    }, '设置→个人信息修改→退出登录');
    
    this.results.push({
      flowName: '设置→个人信息修改→退出登录',
      passed,
      duration: Date.now() - startTime,
    });
  }
  
  // 运行所有测试
  async runAll(): Promise<void> {
    console.info('🛤️ ===== 开始E2E测试 =====');
    
    await this.testNewUserJourney();
    await this.testBrowseAndBuyJourney();
    await this.testOrderManagementJourney();
    await this.testSettingsJourney();
    
    this.printReport();
  }
  
  // 打印报告
  printReport(): void {
    console.info('\n🛤️ ===== E2E测试报告 =====');
    console.info('─'.repeat(60));
    
    for (const r of this.results) {
      const status = r.passed ? '✅' : '❌';
      const duration = (r.duration / 1000).toFixed(1);
      console.info(`${status} ${r.flowName}: ${duration}s${r.error ? ' - ' + r.error : ''}`);
    }
    
    const passed = this.results.filter(r => r.passed).length;
    const total = this.results.length;
    const totalDuration = this.results.reduce((sum, r) => sum + r.duration, 0);
    
    console.info('─'.repeat(60));
    console.info(`通过率: ${passed}/${total} (${(passed / total * 100).toFixed(0)}%)`);
    console.info(`总耗时: ${(totalDuration / 1000).toFixed(1)}s`);
  }
}

// 执行测试
export default async function runE2ETest() {
  const suite = new E2ETestSuite();
  await suite.runAll();
}

踩坑与注意事项

坑1：E2E测试的"脆弱性"

E2E测试最大的问题是脆弱。网络慢了、接口超时了、数据被别人改了——测试就挂了，但代码没bug。

解决方案：

1. 重试机制：单次失败自动重试2-3次
2. 智能等待：用条件等待替代固定sleep
3. Mock外部依赖：测试环境用Mock数据，不依赖真实后端
4. 分离不稳定因素：网络相关的操作单独处理，不影响主流程判断

坑2：测试数据的管理

E2E测试需要真实数据。你注册了一个测试账号，跑完测试账号就"脏"了——下次跑的时候这个账号已经注册过了，注册流程必然失败。

解决方案：

1. 每次测试生成唯一的测试数据（加时间戳）
2. 测试结束后清理数据
3. 使用专门的测试环境，和生产环境完全隔离

// 生成唯一测试数据
const uniqueUsername = `e2e_test_${Date.now()}`;
const uniquePhone = `138${Math.floor(Math.random() * 100000000).toString().padStart(8, '0')}`;

坑3：测试执行顺序依赖

E2E测试之间不应该有顺序依赖。“注册流程"和"购物流程"应该能独立运行，不能要求"必须先跑注册再跑购物”。

解决方案：每个测试用例自己准备数据、自己清理数据。如果需要登录状态，在测试开始时自动登录，不要依赖上一个测试的登录结果。

坑4：执行时间过长

E2E测试慢是正常的——一个完整的购物流程可能要30秒。如果跑20个E2E测试，就是10分钟。这在CI流水线里很难接受。

解决方案：

1. 只对核心流程写E2E测试，其他场景用集成测试覆盖
2. E2E测试可以定时跑（比如每天夜间），不用每次提交都跑
3. 并行执行：不同链路的E2E测试可以并行跑

坑5：页面返回的"栈溢出"

E2E测试中经常需要返回上一页。但如果你的测试跳转了5个页面，按5次返回键可能回不到首页——中间某个页面拦截了返回事件。

解决方案：不要依赖返回键回到首页，直接点击底部Tab的"首页"按钮。

HarmonyOS 6适配说明

HarmonyOS 6对E2E测试做了以下增强：

1. 测试状态快照：driver.saveState()/driver.restoreState()可以保存和恢复App状态，测试失败时快速恢复到断点
2. 网络Mock：内置网络请求Mock能力，E2E测试不再依赖真实后端
3. 并行执行支持：支持在多个设备上并行跑E2E测试，缩短总执行时间
4. 视频录制：E2E测试执行过程自动录屏，失败时可以回放查看
5. 链路追踪：E2E测试和后端链路追踪集成，测试失败时可以查看完整的请求链路

迁移注意：assertComponentExistence在API 13中新增了assertComponentExistence(selector, options)重载，options可以指定等待策略（立即返回/等待出现/等待消失）。

总结

E2E测试是测试金字塔的顶端——数量最少但价值最高。它验证的是用户真正关心的东西：业务能不能跑通。但E2E测试也是最脆弱的，需要精心设计才能保持稳定。

核心原则：E2E测试只覆盖核心业务流程，不追求数量追求质量。一个稳定的购物流程E2E测试，比10个时灵时不灵的边缘场景测试更有价值。把精力花在提高稳定性上，而不是增加覆盖率上。