mini-starter/web/tests/e2e/specs/cross-platform/order-list-validation.spec.ts

import { TIMEOUTS } from '../../utils/timeouts';
import { test, expect } from '../../utils/test-setup';
import { EnterpriseMiniPage } from '../../pages/mini/enterprise-mini.page';
import { AdminLoginPage } from '../../pages/admin/login.page';
import { ORDER_STATUS } from '../../pages/admin/order-management.page';

/**
 * 订单列表页完整验证 E2E 测试 (Story 13.8)
 *
 * 测试目标：验证企业小程序订单列表页的完整功能
 *
 * 测试流程：
 * 1. 企业用户登录小程序
 * 2. 导航到订单列表页
 * 3. 验证订单列表显示
 * 4. 验证筛选功能
 * 5. 验证搜索功能
 * 6. 验证订单卡片交互（查看详情）
 *
 * Playwright MCP 探索结果 (2026-01-14):
 * - 小程序订单列表页没有 data-testid 属性
 * - 使用 Taro 组件 (taro-view-core, taro-text-core)
 * - 需要使用文本选择器和 CSS 类选择器
 * - 订单卡片包含：订单名称、创建日期、状态、人数、日期、统计信息
 * - 点击"查看详情"成功导航到订单详情页
 */

// 测试常量
const TEST_USER_PHONE = '13800001111'; // 小程序登录手机号
const TEST_USER_PASSWORD = process.env.TEST_ENTERPRISE_PASSWORD || 'password123'; // 小程序登录密码

/**
 * 订单列表页常量（基于 Playwright MCP 探索）
 */
const ORDER_LIST_SELECTORS = {
  // 页面
  pageUrl: '/mini/#/mini/pages/yongren/order/list/index',
  pageTitle: '订单列表',

  // 筛选标签（文本选择器）
  filterTabs: {
    all: '全部订单',
    inProgress: '进行中',
    completed: '已完成',
    cancelled: '已取消',
  },

  // 搜索
  searchPlaceholder: '按订单号、人才姓名搜索',
  searchButton: '搜索',

  // 订单卡片
  orderCard: '.bg-white', // CSS 类选择器
  viewDetailButton: '查看详情', // 文本选择器

  // 底部导航
  bottomNav: {
    home: '首页',
    talent: '人才',
    order: '订单',
    data: '数据',
    settings: '设置',
  },
} as const;

test.describe('订单列表页完整验证 - Story 13.8', () => {
  // 每个测试使用独立的浏览器上下文
  test.use({ storageState: undefined });

  /**
   * 测试场景：订单列表基础功能验证 (AC1)
   */
  test.describe.serial('订单列表基础功能测试 (AC1)', () => {
    test.use({ storageState: undefined });

    test('应该成功加载订单列表并显示订单卡片', async ({ enterpriseMiniPage: miniPage }) => {
      // 1. 登录小程序
      await miniPage.goto();
      await miniPage.login(TEST_USER_PHONE, TEST_USER_PASSWORD);
      await miniPage.expectLoginSuccess();
      await miniPage.page.waitForTimeout(TIMEOUTS.MEDIUM);

      // 2. 导航到订单列表页
      await miniPage.page.goto(`http://localhost:8080${ORDER_LIST_SELECTORS.pageUrl}`);
      await miniPage.page.waitForTimeout(TIMEOUTS.LONG);

      // 3. 验证页面标题
      const pageTitle = await miniPage.page.title();
      expect(pageTitle).toBe(ORDER_LIST_SELECTORS.pageTitle);

      // 4. 验证订单卡片显示
      // 注意：小程序订单列表页没有 data-testid，使用 CSS 类选择器
      const orderCards = miniPage.page.locator(ORDER_LIST_SELECTORS.orderCard);
      const cardCount = await orderCards.count();

      // 验证至少有一个订单卡片（排除导航栏等元素）
      expect(cardCount).toBeGreaterThan(0);
      console.debug(`[订单列表] 找到 ${cardCount} 个订单卡片`);

      // 5. 验证筛选区域可见
      const filterTabs = miniPage.page.getByText(ORDER_LIST_SELECTORS.filterTabs.all);
      await expect(filterTabs).toBeVisible();
      console.debug('[订单列表] 筛选标签可见');
    });

    test('订单卡片应该显示所有必填字段', async ({ enterpriseMiniPage: miniPage }) => {
      // 1. 登录并导航到订单列表
      await miniPage.goto();
      await miniPage.login(TEST_USER_PHONE, TEST_USER_PASSWORD);
      await miniPage.expectLoginSuccess();
      await miniPage.page.goto(`http://localhost:8080${ORDER_LIST_SELECTORS.pageUrl}`);
      await miniPage.page.waitForTimeout(TIMEOUTS.LONG);

      // 2. 获取页面内容验证订单信息显示
      // 基于实际探索，订单列表页包含订单名称、状态、人数等信息
      const pageText = await miniPage.page.textContent('body');

      // 3. 验证页面包含订单相关信息
      expect(pageText).toBeDefined();
      expect(pageText!.length).toBeGreaterThan(0);

      // 4. 验证包含状态关键词（基于实际探索：草稿/进行中/已完成/已取消）
      const hasStatus = pageText!.match(/草稿|进行中|已完成|已取消/);
      expect(hasStatus).toBeTruthy();

      // 5. 验证包含人数信息（基于实际探索：0人）
      expect(pageText).toContain('人');

      // 6. 验证包含日期信息（基于实际探索：YYYY-MM-DD 格式或 "未设置"）
      const hasDate = pageText!.match(/\d{4}-\d{2}-\d{2}|未设置/);
      expect(hasDate).toBeTruthy();

      console.debug('[订单列表] 订单卡片字段验证通过');
    });

    test('订单状态徽章应该正确显示', async ({ enterpriseMiniPage: miniPage }) => {
      // 1. 登录并导航到订单列表
      await miniPage.goto();
      await miniPage.login(TEST_USER_PHONE, TEST_USER_PASSWORD);
      await miniPage.expectLoginSuccess();
      await miniPage.page.goto(`http://localhost:8080${ORDER_LIST_SELECTORS.pageUrl}`);
      await miniPage.page.waitForTimeout(TIMEOUTS.LONG);

      // 2. 验证订单状态显示
      // 检查页面包含至少一个订单状态
      const statusText = await miniPage.page.textContent('body');
      const hasOrderStatus = statusText?.match(/草稿|进行中|已完成|已取消/);

      expect(hasOrderStatus).toBeTruthy();
      console.debug('[订单列表] 订单状态徽章显示正确');
    });

    test('订单人数和日期信息应该正确显示', async ({ enterpriseMiniPage: miniPage }) => {
      // 1. 登录并导航到订单列表
      await miniPage.goto();
      await miniPage.login(TEST_USER_PHONE, TEST_USER_PASSWORD);
      await miniPage.expectLoginSuccess();
      await miniPage.page.goto(`http://localhost:8080${ORDER_LIST_SELECTORS.pageUrl}`);
      await miniPage.page.waitForTimeout(TIMEOUTS.LONG);

      // 2. 验证人数信息显示
      const pageText = await miniPage.page.textContent('body');
      expect(pageText).toContain('人');
      console.debug('[订单列表] 订单人数显示正确');

      // 3. 验证日期信息显示（格式：YYYY-MM-DD 或 "未设置"）
      const hasDate = pageText?.match(/\d{4}-\d{2}-\d{2}|未设置/);
      expect(hasDate).toBeTruthy();
      console.debug('[订单列表] 订单日期显示正确');
    });
  });

  /**
   * 测试场景：订单列表交互功能验证 (AC7)
   */
  test.describe.serial('订单列表交互功能测试 (AC7)', () => {
    test.use({ storageState: undefined });

    test('应该点击订单卡片跳转到订单详情页', async ({ enterpriseMiniPage: miniPage }) => {
      // 1. 登录并导航到订单列表
      await miniPage.goto();
      await miniPage.login(TEST_USER_PHONE, TEST_USER_PASSWORD);
      await miniPage.expectLoginSuccess();
      await miniPage.page.goto(`http://localhost:8080${ORDER_LIST_SELECTORS.pageUrl}`);
      await miniPage.page.waitForTimeout(TIMEOUTS.LONG);

      // 2. 记录当前 URL
      const beforeUrl = miniPage.page.url();
      console.debug(`[详情页] 当前 URL: ${beforeUrl}`);

      // 3. 点击"查看详情"按钮
      // 使用 evaluate 直接点击，避免被其他元素阻挡
      await miniPage.page.evaluate((buttonText) => {
        const buttons = Array.from(document.querySelectorAll('*'));
        const targetButton = buttons.find(el =>
          el.textContent?.includes(buttonText) && el.textContent?.trim() === buttonText
        );
        if (targetButton) {
          (targetButton as HTMLElement).click();
        }
      }, ORDER_LIST_SELECTORS.viewDetailButton);

      // 4. 等待导航完成
      await miniPage.page.waitForTimeout(TIMEOUTS.MEDIUM);

      // 5. 验证 URL 已改变（包含订单详情页路径）
      const afterUrl = miniPage.page.url();
      console.debug(`[详情页] 导航后 URL: ${afterUrl}`);

      expect(afterUrl).toContain('/mini/pages/yongren/order/detail/index');
      expect(afterUrl).toContain('id=');

      console.debug('[详情页] 成功导航到订单详情页');
    });

    test('应该可以从详情页返回列表页', async ({ enterpriseMiniPage: miniPage }) => {
      // 1. 登录并导航到订单列表
      await miniPage.goto();
      await miniPage.login(TEST_USER_PHONE, TEST_USER_PASSWORD);
      await miniPage.expectLoginSuccess();
      await miniPage.page.goto(`http://localhost:8080${ORDER_LIST_SELECTORS.pageUrl}`);
      await miniPage.page.waitForTimeout(TIMEOUTS.LONG);

      // 2. 点击"查看详情"进入订单详情页
      await miniPage.page.evaluate((buttonText) => {
        const buttons = Array.from(document.querySelectorAll('*'));
        const targetButton = buttons.find(el =>
          el.textContent?.includes(buttonText) && el.textContent?.trim() === buttonText
        );
        if (targetButton) {
          (targetButton as HTMLElement).click();
        }
      }, ORDER_LIST_SELECTORS.viewDetailButton);
      await miniPage.page.waitForTimeout(TIMEOUTS.MEDIUM);

      // 3. 验证在详情页
      const detailUrl = miniPage.page.url();
      expect(detailUrl).toContain('/mini/pages/yongren/order/detail/index');

      // 4. 返回列表页（使用 EnterpriseMiniPage 的 clickBottomNav 方法）
      await miniPage.clickBottomNav('order');
      await miniPage.page.waitForTimeout(TIMEOUTS.MEDIUM);

      // 5. 验证返回到列表页
      const listUrl = miniPage.page.url();
      expect(listUrl).toContain('/mini/pages/yongren/order/list');

      console.debug('[详情页] 成功返回到订单列表页');
    });
  });

  /**
   * 测试场景：订单状态筛选功能验证 (AC2)
   */
  test.describe.serial('订单状态筛选功能测试 (AC2)', () => {
    test.use({ storageState: undefined });

    test('应该显示所有筛选标签', async ({ enterpriseMiniPage: miniPage }) => {
      // 1. 登录并导航到订单列表
      await miniPage.goto();
      await miniPage.login(TEST_USER_PHONE, TEST_USER_PASSWORD);
      await miniPage.expectLoginSuccess();
      await miniPage.page.goto(`http://localhost:8080${ORDER_LIST_SELECTORS.pageUrl}`);
      await miniPage.page.waitForTimeout(TIMEOUTS.LONG);

      // 2. 验证所有筛选标签可见
      const { filterTabs } = ORDER_LIST_SELECTORS;

      // 使用 .first() 避免 strict mode violation
      await expect(miniPage.page.getByText(filterTabs.all).first()).toBeVisible();
      await expect(miniPage.page.getByText(filterTabs.inProgress).first()).toBeVisible();
      await expect(miniPage.page.getByText(filterTabs.completed).first()).toBeVisible();
      await expect(miniPage.page.getByText(filterTabs.cancelled).first()).toBeVisible();

      console.debug('[筛选] 所有筛选标签可见');
    });

    test('应该可以按订单状态筛选 - 进行中', async ({ enterpriseMiniPage: miniPage }) => {
      // 1. 登录并导航到订单列表
      await miniPage.goto();
      await miniPage.login(TEST_USER_PHONE, TEST_USER_PASSWORD);
      await miniPage.expectLoginSuccess();
      await miniPage.page.goto(`http://localhost:8080${ORDER_LIST_SELECTORS.pageUrl}`);
      await miniPage.page.waitForTimeout(TIMEOUTS.LONG);

      // 2. 点击"进行中"筛选标签
      await miniPage.page.evaluate((tabText) => {
        const tabs = Array.from(document.querySelectorAll('*'));
        const targetTab = tabs.find(el =>
          el.textContent?.includes(tabText) && el.textContent?.trim() === tabText
        );
        if (targetTab) {
          (targetTab as HTMLElement).click();
        }
      }, ORDER_LIST_SELECTORS.filterTabs.inProgress);

      await miniPage.page.waitForTimeout(TIMEOUTS.MEDIUM);

      // 3. 验证筛选结果：检查页面包含"进行中"状态
      const pageText = await miniPage.page.textContent('body');
      const hasInProgressStatus = pageText?.includes('进行中');
      expect(hasInProgressStatus).toBe(true);

      // 4. 验证筛选后的订单列表
      const filteredCards = miniPage.page.locator(ORDER_LIST_SELECTORS.orderCard);
      const filteredCount = await filteredCards.count();

      // 验证筛选后有订单显示（至少有进行中状态的订单）
      expect(filteredCount).toBeGreaterThan(0);
      console.debug(`[筛选] 筛选后订单数量: ${filteredCount}`);

      // 5. 进一步验证：检查筛选结果确实包含"进行中"状态的订单
      let foundMatchingOrder = false;
      for (let i = 0; i < Math.min(filteredCount, 3); i++) {
        const cardText = await filteredCards.nth(i).textContent();
        if (cardText?.includes('进行中')) {
          foundMatchingOrder = true;
          console.debug(`[筛选] 订单 ${i + 1} 包含"进行中"状态`);
          break;
        }
      }
      expect(foundMatchingOrder).toBe(true);

      console.debug('[筛选] 筛选功能验证通过');
    });
  });

  /**
   * 测试场景：订单搜索功能验证 (AC4)
   */
  test.describe.serial('订单搜索功能测试 (AC4)', () => {
    test.use({ storageState: undefined });

    test('应该显示搜索框和搜索按钮', async ({ enterpriseMiniPage: miniPage }) => {
      // 1. 登录并导航到订单列表
      await miniPage.goto();
      await miniPage.login(TEST_USER_PHONE, TEST_USER_PASSWORD);
      await miniPage.expectLoginSuccess();
      await miniPage.page.goto(`http://localhost:8080${ORDER_LIST_SELECTORS.pageUrl}`);
      await miniPage.page.waitForTimeout(TIMEOUTS.LONG);

      // 2. 验证搜索框可见
      // 使用 .first() 避免 strict mode violation（有多个搜索框）
      const searchInput = miniPage.page.getByPlaceholder(ORDER_LIST_SELECTORS.searchPlaceholder).first();
      await expect(searchInput).toBeVisible();

      // 3. 验证搜索按钮可见
      const searchButton = miniPage.page.getByText(ORDER_LIST_SELECTORS.searchButton);
      await expect(searchButton).toBeVisible();

      console.debug('[搜索] 搜索框和搜索按钮可见');
    });

    test('应该可以按订单名称搜索并显示筛选结果', async ({ enterpriseMiniPage: miniPage }) => {
      // 1. 登录并导航到订单列表
      await miniPage.goto();
      await miniPage.login(TEST_USER_PHONE, TEST_USER_PASSWORD);
      await miniPage.expectLoginSuccess();
      await miniPage.page.goto(`http://localhost:8080${ORDER_LIST_SELECTORS.pageUrl}`);
      await miniPage.page.waitForTimeout(TIMEOUTS.LONG);

      // 2. 记录初始订单数量
      const initialCards = miniPage.page.locator(ORDER_LIST_SELECTORS.orderCard);
      const initialCount = await initialCards.count();
      console.debug(`[搜索] 初始订单数量: ${initialCount}`);

      // 3. 在搜索框输入已知存在的订单关键词
      // 基于实际探索：搜索 "Epic13" 应该能找到匹配的订单
      const searchInput = miniPage.page.getByPlaceholder(ORDER_LIST_SELECTORS.searchPlaceholder).first();
      const searchKeyword = 'Epic13';
      await searchInput.type(searchKeyword);

      // 4. 等待搜索自动触发（基于探索：搜索是自动触发的）
      await miniPage.page.waitForTimeout(TIMEOUTS.MEDIUM);

      // 5. 验证搜索输入成功
      const inputValue = await searchInput.evaluate((el: any) => el.value || el.textContent);
      expect(inputValue).toContain(searchKeyword);
      console.debug(`[搜索] 搜索关键词已输入: ${searchKeyword}`);

      // 6. 验证搜索结果：检查页面包含搜索关键词
      const pageText = await miniPage.page.textContent('body');
      const hasKeyword = pageText?.includes(searchKeyword);
      expect(hasKeyword).toBe(true);

      // 7. 验证搜索结果只包含匹配的订单
      const searchResults = miniPage.page.locator(ORDER_LIST_SELECTORS.orderCard);
      const resultCount = await searchResults.count();

      // 验证有搜索结果
      expect(resultCount).toBeGreaterThan(0);
      console.debug(`[搜索] 搜索结果数量: ${resultCount}`);

      // 8. 验证搜索结果确实包含搜索关键词
      let foundMatchingResult = false;
      for (let i = 0; i < Math.min(resultCount, 3); i++) {
        const cardText = await searchResults.nth(i).textContent();
        if (cardText?.includes(searchKeyword)) {
          foundMatchingResult = true;
          console.debug(`[搜索] 搜索结果 ${i + 1} 包含关键词 "${searchKeyword}"`);
          break;
        }
      }
      expect(foundMatchingResult).toBe(true);

      console.debug('[搜索] 搜索功能验证通过');
    });
  });

  /**
   * 测试场景：后台编辑后订单列表同步验证 (AC3, AC5)
   *
   * 测试流程：
   * 1. 后台登录并创建/编辑订单
   * 2. 小程序验证订单信息同步
   * 3. 验证数据同步时间（≤ 10 秒）
   */
  test.describe.serial('后台编辑后订单列表同步测试 (AC3, AC5)', () => {
    test.use({ storageState: undefined });

    // 管理员登录凭据
    const ADMIN_USERNAME = 'admin';
    const ADMIN_PASSWORD = process.env.TEST_ADMIN_PASSWORD || 'admin123';

    /**
     * 辅助函数：执行管理员登录
     * @param adminLoginPage 管理员登录页面对象
     */
    async function adminLogin(adminLoginPage: AdminLoginPage): Promise<void> {
      await adminLoginPage.goto();
      await adminLoginPage.login(ADMIN_USERNAME, ADMIN_PASSWORD);
      // 验证登录成功
      await adminLoginPage.page.waitForURL('/admin/dashboard', { timeout: TIMEOUTS.PAGE_LOAD });
    }

    /**
     * 辅助函数：等待订单在小程序列表中更新
     * @param miniPage 小程序页面
     * @param orderName 订单名称
     * @param timeout 超时时间（毫秒）
     * @returns 是否在超时时间内检测到更新
     */
    async function waitForOrderUpdate(miniPage: EnterpriseMiniPage, orderName: string, timeout: number = 10000): Promise<boolean> {
      const startTime = Date.now();
      while (Date.now() - startTime < timeout) {
        // 刷新页面
        await miniPage.page.reload({ waitUntil: 'domcontentloaded', timeout: TIMEOUTS.PAGE_LOAD });
        await miniPage.page.waitForTimeout(TIMEOUTS.SHORT);

        // 检查订单是否出现
        const pageText = await miniPage.page.textContent('body');
        if (pageText && pageText.includes(orderName)) {
          return true;
        }

        await miniPage.page.waitForTimeout(500);
      }
      return false;
    }

    /**
     * 辅助函数：在小程序订单列表中查找订单
     * @param miniPage 小程序页面
     * @param orderName 订单名称
     * @returns 是否找到订单
     */
    async function findOrderInList(miniPage: EnterpriseMiniPage, orderName: string): Promise<boolean> {
      const pageText = await miniPage.page.textContent('body');
      if (!pageText) return false;

      // 检查是否包含订单名称
      const hasOrderName = pageText.includes(orderName);
      return hasOrderName;
    }

    test('后台修改订单名称后小程序同步', async ({ enterpriseMiniPage: miniPage, orderManagementPage: adminPage, adminLoginPage }) => {
      // 测试数据
      const originalName = `E2E测试_名称同步_${Date.now()}`;
      const updatedName = `${originalName}_已更新`;

      // 1. 后台登录并创建订单（关联到测试公司）
      await adminLogin(adminLoginPage);
      await adminPage.goto();
      const createResult = await adminPage.createOrder({
        name: originalName,
        companyName: '测试公司', // 关联到测试公司，确保小程序能显示
        expectedStartDate: '2026-02-01',
      });

      expect(createResult.success).toBe(true);
      console.debug(`[跨端同步] 后台创建订单成功: ${originalName}`);

      // 2. 小程序验证订单显示
      await miniPage.goto();
      await miniPage.login(TEST_USER_PHONE, TEST_USER_PASSWORD);
      await miniPage.expectLoginSuccess();
      await miniPage.navigateToOrderList();

      // 等待订单出现
      const found = await waitForOrderUpdate(miniPage, originalName, TIMEOUTS.OPERATION);
      expect(found).toBe(true);
      console.debug(`[跨端同步] 小程序显示订单: ${originalName}`);

      // 3. 后台修改订单名称
      await adminLogin(adminLoginPage);
      await adminPage.goto();
      const editResult = await adminPage.editOrder(originalName, {
        name: updatedName, // 编辑时需要提供 name
        companyName: '测试公司',
      });

      expect(editResult.success).toBe(true);
      console.debug(`[跨端同步] 后台修改订单名称: ${originalName} → ${updatedName}`);

      // 4. 小程序验证订单名称更新
      await miniPage.navigateToOrderList();
      const updated = await waitForOrderUpdate(miniPage, updatedName, TIMEOUTS.OPERATION);
      expect(updated).toBe(true);

      // 验证旧名称不再存在
      const oldNameExists = await findOrderInList(miniPage, originalName);
      expect(oldNameExists).toBe(false);

      console.debug(`[跨端同步] 小程序订单名称已更新: ${updatedName}`);
    });

    test('后台修改订单状态后小程序同步', async ({ enterpriseMiniPage: miniPage, orderManagementPage: adminPage, adminLoginPage }) => {
      // 测试数据
      const orderName = `E2E测试_状态同步_${Date.now()}`;

      // 1. 后台登录并创建订单（默认草稿状态）
      await adminLogin(adminLoginPage);
      await adminPage.goto();
      const createResult = await adminPage.createOrder({
        name: orderName,
        status: ORDER_STATUS.DRAFT,
        companyName: '测试公司',
        expectedStartDate: '2026-02-01',
      });

      expect(createResult.success).toBe(true);
      console.debug(`[跨端同步] 后台创建订单: ${orderName}, 状态: 草稿`);

      // 2. 小程序验证订单显示
      await miniPage.goto();
      await miniPage.login(TEST_USER_PHONE, TEST_USER_PASSWORD);
      await miniPage.expectLoginSuccess();
      await miniPage.navigateToOrderList();

      const found = await waitForOrderUpdate(miniPage, orderName, TIMEOUTS.OPERATION);
      expect(found).toBe(true);
      console.debug(`[跨端同步] 小程序显示订单: ${orderName}`);

      // 3. 后台修改订单状态为"进行中"
      await adminLogin(adminLoginPage);
      await adminPage.goto();
      const editResult = await adminPage.editOrder(orderName, {
        name: orderName, // 编辑时需要提供 name
        companyName: '测试公司',
        status: ORDER_STATUS.IN_PROGRESS,
      });

      expect(editResult.success).toBe(true);
      console.debug(`[跨端同步] 后台修改订单状态: 草稿 → 进行中`);

      // 4. 小程序验证订单状态更新
      await miniPage.navigateToOrderList();
      await miniPage.page.waitForTimeout(TIMEOUTS.MEDIUM);

      // 检查页面包含"进行中"状态
      const pageText = await miniPage.page.textContent('body');
      expect(pageText).toContain('进行中');

      console.debug(`[跨端同步] 小程序订单状态已更新: 进行中`);
    });

    test('后台修改日期后小程序同步', async ({ enterpriseMiniPage: miniPage, orderManagementPage: adminPage, adminLoginPage }) => {
      // 测试数据
      const orderName = `E2E测试_日期同步_${Date.now()}`;
      const originalDate = '2026-02-01';
      const updatedDate = '2026-03-15';

      // 1. 后台登录并创建订单
      await adminLogin(adminLoginPage);
      await adminPage.goto();
      const createResult = await adminPage.createOrder({
        name: orderName,
        companyName: '测试公司',
        expectedStartDate: originalDate,
      });

      expect(createResult.success).toBe(true);
      console.debug(`[跨端同步] 后台创建订单: ${orderName}, 开始日期: ${originalDate}`);

      // 2. 小程序验证订单显示
      await miniPage.goto();
      await miniPage.login(TEST_USER_PHONE, TEST_USER_PASSWORD);
      await miniPage.expectLoginSuccess();
      await miniPage.navigateToOrderList();

      const found = await waitForOrderUpdate(miniPage, orderName, TIMEOUTS.OPERATION);
      expect(found).toBe(true);

      // 验证日期显示
      const initialPageText = await miniPage.page.textContent('body');
      expect(initialPageText).toContain(originalDate);
      console.debug(`[跨端同步] 小程序显示日期: ${originalDate}`);

      // 3. 后台修改预计开始日期
      await adminLogin(adminLoginPage);
      await adminPage.goto();
      const editResult = await adminPage.editOrder(orderName, {
        name: orderName, // 编辑时需要提供 name
        companyName: '测试公司',
        expectedStartDate: updatedDate,
      });

      expect(editResult.success).toBe(true);
      console.debug(`[跨端同步] 后台修改日期: ${originalDate} → ${updatedDate}`);

      // 4. 小程序验证日期更新
      await miniPage.navigateToOrderList();
      await miniPage.page.waitForTimeout(TIMEOUTS.MEDIUM);

      // 检查更新后的日期
      const updatedPageText = await miniPage.page.textContent('body');
      expect(updatedPageText).toContain(updatedDate);

      console.debug(`[跨端同步] 小程序日期已更新: ${updatedDate}`);
    });

    test('验证数据同步时间（≤ 10 秒）', async ({ enterpriseMiniPage: miniPage, orderManagementPage: adminPage, adminLoginPage }) => {
      // 测试数据
      const orderName = `E2E测试_同步时间_${Date.now()}`;
      const SYNC_TIMEOUT = 10000; // 10 秒

      // 1. 后台登录并创建订单
      await adminLogin(adminLoginPage);
      await adminPage.goto();
      const createResult = await adminPage.createOrder({
        name: orderName,
        companyName: '测试公司',
        expectedStartDate: '2026-02-01',
      });

      expect(createResult.success).toBe(true);
      console.debug(`[跨端同步] 后台创建订单: ${orderName}`);

      // 2. 记录开始时间并等待小程序显示
      const startTime = Date.now();

      await miniPage.goto();
      await miniPage.login(TEST_USER_PHONE, TEST_USER_PASSWORD);
      await miniPage.expectLoginSuccess();
      await miniPage.navigateToOrderList();

      // 等待订单出现，最多等待 10 秒
      const found = await waitForOrderUpdate(miniPage, orderName, SYNC_TIMEOUT);

      const syncTime = Date.now() - startTime;
      console.debug(`[跨端同步] 数据同步耗时: ${syncTime}ms`);

      // 验证订单在 10 秒内同步
      expect(found).toBe(true);
      expect(syncTime).toBeLessThanOrEqual(SYNC_TIMEOUT);

      console.debug(`[跨端同步] 数据同步时间验证通过: ${syncTime}ms ≤ ${SYNC_TIMEOUT}ms`);
    });
  });

  /**
   * 测试场景：底部导航验证 (AC7)
   */
  test.describe.serial('底部导航功能测试', () => {
    test.use({ storageState: undefined });

    test('应该显示底部导航栏', async ({ enterpriseMiniPage: miniPage }) => {
      // 1. 登录并导航到订单列表
      await miniPage.goto();
      await miniPage.login(TEST_USER_PHONE, TEST_USER_PASSWORD);
      await miniPage.expectLoginSuccess();
      await miniPage.page.goto(`http://localhost:8080${ORDER_LIST_SELECTORS.pageUrl}`);
      await miniPage.page.waitForTimeout(TIMEOUTS.LONG);

      // 2. 验证底部导航栏可见
      const { bottomNav } = ORDER_LIST_SELECTORS;

      // 使用 .nth() 或 CSS 类选择器避免 strict mode violation
      // 底部导航栏在页面底部，使用更具体的选择器
      await expect(miniPage.page.getByText(bottomNav.home)).toBeVisible();
      await expect(miniPage.page.getByText(bottomNav.talent)).toBeVisible();
      // "订单"文本出现在多个位置，使用 exact: true 精确匹配底部导航
      await expect(miniPage.page.getByText(bottomNav.order, { exact: true })).toBeVisible();
      await expect(miniPage.page.getByText(bottomNav.data, { exact: true })).toBeVisible();
      await expect(miniPage.page.getByText(bottomNav.settings, { exact: true })).toBeVisible();

      console.debug('[导航] 底部导航栏可见');
    });

    test('应该可以通过底部导航返回首页', async ({ enterpriseMiniPage: miniPage }) => {
      // 1. 登录并导航到订单列表
      await miniPage.goto();
      await miniPage.login(TEST_USER_PHONE, TEST_USER_PASSWORD);
      await miniPage.expectLoginSuccess();
      await miniPage.page.goto(`http://localhost:8080${ORDER_LIST_SELECTORS.pageUrl}`);
      await miniPage.page.waitForTimeout(TIMEOUTS.LONG);

      // 2. 点击"首页"导航（使用 EnterpriseMiniPage 的 clickBottomNav 方法）
      await miniPage.clickBottomNav('home');
      await miniPage.page.waitForTimeout(TIMEOUTS.MEDIUM);

      // 3. 验证导航到首页
      const currentUrl = miniPage.page.url();
      expect(currentUrl).toContain('/mini/pages/yongren/dashboard');

      console.debug('[导航] 成功返回首页');
    });
  });
});