Merge branch 'xfbhzxt'

赵旭婷
2 parents 486d0cf6 4675d8dc
Showing 14 changed files with 3254 additions and 122 deletions
.gitignore
fixtures/testFixture.ts
pages/accountPage.ts
pages/customerGroupPage.ts
pages/customerPage.ts
pages/employeePage.ts
pages/productCategoryPage.ts
pages/purchasePage.ts
scripts/save-auth.ts
tests/account.spec.ts
tests/customerGroup.spec.ts
tests/employee.spec.ts
tests/productCategory.spec.ts
tests/purchase.spec.ts
@@ -11,4 +11,7 @@ node_modules/
 /allure-results/
 /plans/
 /reports/
-/screenshots/
 \ No newline at end of file
+/screenshots/
+/CLAUDE.md
+/docs/
+/.worktrees/
 \ No newline at end of file
 import { test as base, Page } from '@playwright/test';
 import { LoginPage } from '../pages/loginPage';
 import { ProductPage } from '../pages/productPage';
+import { ProductCategoryPage } from '../pages/productCategoryPage';
 import { SalePage } from '../pages/salePage';
 import { ConsignmentPage } from '../pages/consignmentPage';
 import { CustomerPage } from '../pages/customerPage';
+import { PurchasePage } from '../pages/purchasePage';
  
 /**
  * 页面对象夹具类型定义
@@ -20,6 +22,11 @@ export type PageFixtures = {
   productPage: ProductPage;
  
   /**
+   * 商品分类页面
+   */
+  // productCategoryPage: ProductCategoryPage;
+  
+  /**
    * 销售开单页面
    */
   salePage: SalePage;
@@ -33,6 +40,11 @@ export type PageFixtures = {
    * 客户管理页面
    */
   customerPage: CustomerPage;
+  
+  /**
+   * 采购入库页面
+   */
+  purchasePage: PurchasePage;
 };
  
 /**
@@ -49,6 +61,11 @@ export const test = base.extend&lt;PageFixtures&gt;({
     await use(new ProductPage(page));
   },
  
+  // // 商品分类页面
+  // productCategoryPage: async ({ page }, use) => {
+  //   await use(new ProductCategoryPage(page));
+  // },
+  
   // 销售开单页面
   salePage: async ({ page }, use) => {
     await use(new SalePage(page));
@@ -63,6 +80,11 @@ export const test = base.extend&lt;PageFixtures&gt;({
   customerPage: async ({ page }, use) => {
     await use(new CustomerPage(page));
   },
+  
+  // 采购入库页面
+  purchasePage: async ({ page }, use) => {
+    await use(new PurchasePage(page));
+  },
 });
  
 /**
+import { Page, Locator, expect } from '@playwright/test';
+import { BasePage } from './basePage';
+
+/**
+ * 账目管理页面选择器
+ */
+const selectors = {
+  // 导航
+  moreMenu: 'text=更多 >',
+  accountMenu: 'text=账目管理',
+  
+  // 操作按钮
+  addButton: 'text=新增',
+  saveButton: 'text=保存',
+  
+  // 表单字段
+  accountNameInput: 'uni-input:has-text("科目名称") input',
+  remarkTextarea: 'uni-scroll-view textarea',
+  
+  // 收支类型单选
+  incomeRadio: '.nut-radio-group > uni-view:nth-child(1) > .nut-icon',
+  expenseRadio: '.nut-radio-group > uni-view:nth-child(2) > .nut-icon',
+};
+
+/**
+ * 账目管理页面类
+ * 处理账目管理相关操作
+ */
+export class AccountPage extends BasePage {
+  // 导航定位器
+  readonly moreMenu: Locator;
+  readonly accountMenu: Locator;
+  
+  // 操作按钮
+  readonly addButton: Locator;
+  readonly saveButton: Locator;
+  readonly editButton: Locator;
+  
+  // 表单字段
+  readonly accountNameInput: Locator;
+  readonly remarkTextarea: Locator;
+  
+  // 收支类型
+  readonly incomeRadio: Locator;
+  readonly expenseRadio: Locator;
+
+  constructor(page: Page) {
+    super(page);
+    
+    this.moreMenu = page.getByText('更多 >');
+    this.accountMenu = page.getByText('账目管理').first();
+    this.addButton = page.getByText('新增', { exact: true });
+    this.saveButton = page.locator('uni-button.execute-btn').filter({ hasText: '保存' });
+    this.editButton = page.locator('uni-button').filter({ hasText: '修改' });
+    this.accountNameInput = page.locator('uni-input').filter({ hasText: '科目名称' }).getByRole('textbox');
+    this.remarkTextarea = page.locator('uni-scroll-view textarea');
+    this.incomeRadio = page.locator('.nut-radio-group > uni-view:nth-child(1) > .nut-icon');
+    this.expenseRadio = page.locator('.nut-radio-group > uni-view:nth-child(2) > .nut-icon');
+  }
+
+  /**
+   * 进入账目管理页面
+   */
+  async openAccountManagement(): Promise<void> {
+    await this.navigate('/');
+    await this.moreMenu.click();
+    await this.page.waitForTimeout(500);
+    await this.accountMenu.click();
+    await this.page.waitForLoadState('networkidle', { timeout: 30000 });
+  }
+
+  /**
+   * 点击新增按钮
+   */
+  async clickAddButton(): Promise<void> {
+    await this.addButton.click();
+    await this.page.waitForTimeout(500);
+  }
+
+  /**
+   * 填写账目名称
+   * @param name 账目名称
+   */
+  async fillAccountName(name: string): Promise<void> {
+    await this.accountNameInput.click();
+    await this.accountNameInput.fill(name);
+  }
+
+  /**
+   * 选择收支类型
+   * @param type '收入' 或 '支出'
+   */
+  async selectIncomeType(type: '收入' | '支出'): Promise<void> {
+    if (type === '支出') {
+      await this.expenseRadio.click();
+    }
+    // 收入是默认选项，无需选择
+  }
+
+  /**
+   * 填写备注
+   * @param remark 备注内容
+   */
+  async fillRemark(remark: string): Promise<void> {
+    await this.remarkTextarea.click();
+    await this.remarkTextarea.fill(remark);
+  }
+
+  /**
+   * 保存账目
+   */
+  async saveAccount(): Promise<void> {
+    await this.saveButton.click();
+    await this.page.waitForTimeout(1000);
+  }
+
+  /**
+   * 搜索账目
+   * @param name 账目名称
+   */
+  async searchAccount(name: string): Promise<void> {
+    await this.page.locator('uni-input').filter({ hasText: '账目名称' }).getByRole('textbox').click();
+    await this.page.locator('uni-input').filter({ hasText: '账目名称' }).getByRole('textbox').fill(name);
+    await this.page.waitForTimeout(1000);
+  }
+
+  /**
+   * 验证账目是否存在
+   * @param name 账目名称
+   * @returns 是否存在
+   */
+  async verifyAccountExists(name: string): Promise<boolean> {
+    const isVisible = await this.page.getByText(name, { exact: true }).isVisible().catch(() => false);
+    return isVisible;
+  }
+
+  /**
+   * 删除账目
+   * @param name 账目名称
+   */
+  async deleteAccount(name: string): Promise<void> {
+    // 搜索账目
+    await this.searchAccount(name);
+    await this.page.waitForTimeout(500);
+    // 点击删除按钮
+    await this.page.getByText('删除').click();
+    await this.page.waitForTimeout(500);
+    // 确认删除
+    await this.page.getByText('确定').click();
+    await this.page.waitForTimeout(1000);
+  }
+
+  /**
+   * 验证账目删除成功
+   * @param name 账目名称
+   * @returns 是否删除成功
+   */
+  async verifyAccountDeleted(name: string): Promise<boolean> {
+    await this.searchAccount(name);
+    await this.page.waitForTimeout(500);
+    const isVisible = await this.page.getByText(name, { exact: true }).isVisible().catch(() => false);
+    return !isVisible;
+  }
+
+  /**
+   * 点击修改按钮
+   */
+  async clickEditButton(): Promise<void> {
+    await this.editButton.click();
+    await this.page.waitForTimeout(500);
+  }
+
+  /**
+   * 修改账目完整流程
+   * @param originalName 原账目名称
+   * @param newName 新账目名称
+   * @param incomeType 收支类型（收入/支出）
+   * @param remark 备注
+   */
+  async updateAccount(originalName: string, newName: string, incomeType?: '收入' | '支出', remark?: string): Promise<void> {
+    // 搜索原账目
+    await this.searchAccount(originalName);
+    await this.page.waitForTimeout(500);
+    // 点击修改按钮
+    await this.clickEditButton();
+    // 修改账目名称
+    await this.accountNameInput.click();
+    await this.accountNameInput.fill(newName);
+    // 修改收支类型
+    if (incomeType === '支出') {
+      await this.expenseRadio.click();
+    }
+    // 修改备注
+    if (remark) {
+      await this.remarkTextarea.click();
+      await this.remarkTextarea.fill(remark);
+    }
+    // 保存
+    await this.saveAccount();
+  }
+
+  /**
+   * 清除搜索框
+   */
+  async clearSearchBox(): Promise<void> {
+    await this.page.locator('.nut-icon.nutui-iconfont.nut-icon-circle-close').click();
+    await this.page.waitForTimeout(500);
+  }
+
+  /**
+   * 新增账目完整流程
+   * @param accountName 账目名称
+   * @param incomeType 收支类型（默认'收入'）
+   * @param remark 备注
+   */
+  async createAccount(accountName: string, incomeType: '收入' | '支出' = '收入', remark?: string): Promise<void> {
+    await this.openAccountManagement();
+    await this.clickAddButton();
+    await this.fillAccountName(accountName);
+    await this.selectIncomeType(incomeType);
+    if (remark) {
+      await this.fillRemark(remark);
+    }
+    await this.saveAccount();
+  }
+
+  /**
+   * 验证账目创建成功
+   * @param accountName 账目名称
+   * @returns 是否创建成功
+   */
+  async verifyAccountCreated(accountName: string): Promise<boolean> {
+    await this.searchAccount(accountName);
+    return await this.verifyAccountExists(accountName);
+  }
+}
+import { Page, Locator, expect } from '@playwright/test';
+import { BasePage } from './basePage';
+
+/**
+ * 客户分组页面选择器
+ */
+const selectors = {
+  // 导航
+  moreMenu: 'text=更多 >',
+  customerGroupMenu: 'text=客户分组',
+  
+  // 操作按钮
+  newButton: 'text=新建',
+  confirmButton: 'text=确定',
+  saveButton: 'text=保存',
+  deleteButton: 'text=删除',
+  editButton: 'text=编辑',
+  
+  // 表单字段
+  groupNameInput: 'text=分组名称*',
+  sortInput: 'textbox',
+  
+  // 搜索
+  searchInput: 'textbox',
+  clearSearchButton: '.nut-searchbar__search-icon',
+};
+
+/**
+ * 客户分组页面类
+ * 处理客户分组相关操作
+ */
+export class CustomerGroupPage extends BasePage {
+  // 导航定位器
+  readonly moreMenu: Locator;
+  readonly customerGroupMenu: Locator;
+  
+  // 操作按钮
+  readonly newButton: Locator;
+  readonly confirmButton: Locator;
+  readonly saveButton: Locator;
+  readonly deleteButton: Locator;
+  readonly editButton: Locator;
+  
+  // 表单字段
+  readonly groupNameInput: Locator;
+  readonly sortInput: Locator;
+  
+  // 搜索
+  readonly searchInput: Locator;
+  readonly clearSearchButton: Locator;
+
+  constructor(page: Page) {
+    super(page);
+    
+    this.moreMenu = page.getByText('更多 >');
+    this.customerGroupMenu = page.getByText('客户分组').first();
+    this.newButton = page.getByText('新建');
+    this.confirmButton = page.getByText('确定');
+    this.saveButton = page.getByText('保存');
+    this.deleteButton = page.getByText('删除');
+    this.editButton = page.getByText('编辑');
+    this.groupNameInput = page.locator('uni-view').filter({ hasText: /^分组名称\*$/ }).first();
+    this.sortInput = page.getByRole('textbox').nth(2);
+    this.searchInput = page.getByRole('textbox');
+    this.clearSearchButton = page.locator('.nut-searchbar__search-icon');
+  }
+
+  /**
+   * 进入客户分组页面
+   */
+  async openCustomerGroupManagement(): Promise<void> {
+    await this.navigate('/');
+    await this.moreMenu.click();
+    await this.page.waitForTimeout(500);
+    await this.customerGroupMenu.click();
+    await this.page.waitForLoadState('networkidle', { timeout: 30000 });
+  }
+
+  /**
+   * 点击新建按钮
+   */
+  async clickNewButton(): Promise<void> {
+    await this.newButton.click();
+    await this.page.waitForTimeout(500);
+  }
+
+  /**
+   * 填写分组名称
+   * @param name 分组名称
+   */
+  async fillGroupName(name: string): Promise<void> {
+    await this.page.getByRole('textbox').nth(1).click();
+    await this.page.getByRole('textbox').nth(1).fill(name);
+  }
+
+  /**
+   * 填写排序号
+   * @param sort 排序号
+   */
+  async fillSortNumber(sort: string): Promise<void> {
+    await this.page.getByRole('textbox').nth(2).click();
+    await this.page.getByRole('textbox').nth(2).fill(sort);
+  }
+
+  /**
+   * 点击确定按钮
+   */
+  async clickConfirm(): Promise<void> {
+    await this.confirmButton.click();
+    await this.page.waitForTimeout(1000);
+  }
+
+  /**
+   * 搜索分组
+   * @param name 分组名称
+   */
+  async searchGroup(name: string): Promise<void> {
+    await this.searchInput.click();
+    await this.searchInput.fill(name);
+    await this.page.waitForTimeout(500);
+  }
+
+  /**
+   * 点击清除搜索按钮
+   */
+  async clearSearch(): Promise<void> {
+    await this.clearSearchButton.click();
+    await this.page.waitForTimeout(2000);
+  }
+
+  /**
+   * 点击编辑按钮
+   */
+  async clickEdit(): Promise<void> {
+    await this.editButton.click();
+    await this.page.waitForTimeout(500);
+  }
+
+  /**
+   * 点击删除按钮
+   */
+  async clickDelete(): Promise<void> {
+    await this.deleteButton.click();
+    await this.page.waitForTimeout(500);
+  }
+
+  /**
+   * 验证分组是否存在（验证前先搜索）
+   * @param name 分组名称
+   * @returns 是否存在
+   */
+  async verifyGroupExists(name: string): Promise<boolean> {
+    await this.searchGroup(name);
+    await this.page.waitForTimeout(500);
+    const count = await this.page.locator('uni-view').filter({ hasText: new RegExp(`^${name}$`) }).count();
+    return count > 0;
+  }
+
+  /**
+   * 验证分组是否不存在
+   * @param name 分组名称
+   * @returns 是否不存在
+   */
+  async verifyGroupNotExists(name: string): Promise<boolean> {
+    const count = await this.page.locator('uni-view').filter({ hasText: new RegExp(`^${name}$`) }).count();
+    return count === 0;
+  }
+
+  /**
+   * 新增客户分组完整流程
+   * @param groupName 分组名称
+   * @param sortNumber 排序号（可选）
+   */
+  async createGroup(groupName: string, sortNumber?: string): Promise<void> {
+    await this.openCustomerGroupManagement();
+    await this.clickNewButton();
+    await this.fillGroupName(groupName);
+    if (sortNumber) {
+      await this.fillSortNumber(sortNumber);
+    }
+    await this.clickConfirm();
+  }
+
+  /**
+   * 修改客户分组完整流程
+   * @param originalName 原分组名称
+   * @param newName 新分组名称
+   * @param newSortNumber 新排序号（可选）
+   */
+  async updateGroup(originalName: string, newName: string, newSortNumber?: string): Promise<void> {
+    await this.searchGroup(originalName);
+    await this.page.locator('uni-view').filter({ hasText: new RegExp(`^${originalName}$`) }).first().click();
+    await this.page.waitForTimeout(500);
+    await this.clickEdit();
+    // 清空分组名称并填写新名称
+    await this.page.getByRole('textbox').nth(1).click();
+    await this.page.locator('.nut-input__clear-icon').first().click();
+    await this.page.getByRole('textbox').nth(1).click();
+    await this.page.getByRole('textbox').nth(1).fill(newName);
+    if (newSortNumber) {
+      await this.page.getByRole('textbox').nth(2).click();
+      await this.page.getByRole('textbox').nth(2).fill(newSortNumber);
+    }
+    await this.clickConfirm();
+  }
+
+  /**
+   * 删除客户分组完整流程
+   * @param groupName 分组名称
+   */
+  async deleteGroup(groupName: string): Promise<void> {
+    await this.searchGroup(groupName);
+    await this.page.locator('uni-view').filter({ hasText: new RegExp(`^${groupName}$`) }).first().click();
+    await this.page.waitForTimeout(500);
+    await this.clickDelete();
+    await this.page.getByText('确定', { exact: true }).click();
+    await this.page.waitForTimeout(1000);
+    await this.clearSearch();
+  }
+}
@@ -182,17 +182,20 @@ export class CustomerPage extends BasePage {
   }
  
   /**
-   * 选择客户分组（选择"普通客户"）
+   * 选择客户分组（随机选择）
    */
   async selectCustomerGroup(): Promise<void> {
     // 点击客户分组选择器
     await this.customerGroupPicker.click();
-    
+     
     // 等待弹窗出现
     await this.page.waitForTimeout(500);
  
-    // 选择"普通客户"（使用 nth(4) 和 force: true 绕过遮罩层）
-    await this.page.locator('uni-view').filter({ hasText: /^普通客户$/ }).nth(4).click({ force: true });
+    // 随机选择一个客户分组
+    const items = this.page.locator('.zp-paging-container-content .default-item');
+    const count = await items.count();
+    const randomIndex = Math.floor(Math.random() * count);
+    await items.nth(randomIndex).click({ force: true });
   }
  
   /**
+import { Page, Locator, expect } from '@playwright/test';
+import { BasePage } from './basePage';
+
+/**
+ * 员工管理页面类
+ * 处理员工管理相关操作
+ */
+export class EmployeePage extends BasePage {
+  // 导航定位器
+  readonly employeeMenu: Locator;
+  
+  // 操作按钮
+  readonly newEmployeeButton: Locator;
+  readonly manualAddButton: Locator;
+  readonly confirmButton: Locator;
+  
+  // 表单字段
+  readonly employeeNameInput: Locator;
+  readonly phoneInput: Locator;
+  readonly remarkInput: Locator;
+  readonly positionInput: Locator;
+  
+  // 岗位列表
+  readonly positionOption: Locator;
+
+  constructor(page: Page) {
+    super(page);
+    
+    this.employeeMenu = page.getByText('员工管理').first();
+    this.newEmployeeButton = page.getByText('新建员工');
+    this.manualAddButton = page.getByText('手动添加');
+    this.confirmButton = page.getByText('确定');
+    this.employeeNameInput = page.locator('uni-input').filter({ hasText: '请输入员工姓名' }).getByRole('textbox');
+    this.phoneInput = page.getByRole('spinbutton');
+    this.remarkInput = page.locator('uni-input').filter({ hasText: '请输入备注信息' }).getByRole('textbox');
+    this.positionInput = page.locator('.nut-cell__link').first();
+    this.positionOption = page.locator('uni-view').filter({ hasText: /^岗位名称$/ }).first();
+  }
+
+  /**
+   * 进入员工管理页面
+   */
+  async openEmployeeManagement(): Promise<void> {
+    await this.navigate('/');
+    await this.employeeMenu.click();
+    await this.page.waitForLoadState('networkidle', { timeout: 30000 });
+  }
+
+  /**
+   * 点击新建员工按钮
+   */
+  async clickNewEmployee(): Promise<void> {
+    await this.newEmployeeButton.click();
+    await this.page.waitForTimeout(500);
+  }
+
+  /**
+   * 点击手动添加
+   */
+  async clickManualAdd(): Promise<void> {
+    await this.manualAddButton.click();
+    await this.page.waitForTimeout(500);
+  }
+
+  /**
+   * 填写员工姓名
+   * @param name 员工姓名
+   */
+  async fillEmployeeName(name: string): Promise<void> {
+    await this.employeeNameInput.click();
+    await this.employeeNameInput.fill(name);
+  }
+
+  /**
+   * 填写联系电话
+   * @param phone 联系电话
+   */
+  async fillPhone(phone: string): Promise<void> {
+    await this.phoneInput.click();
+    await this.phoneInput.fill(phone);
+  }
+
+  /**
+   * 填写备注
+   * @param remark 备注信息
+   */
+  async fillRemark(remark: string): Promise<void> {
+    await this.remarkInput.click();
+    await this.remarkInput.fill(remark);
+  }
+
+  /**
+   * 选择岗位
+   * @param position 岗位名称（可选，不传则随机选择）
+   */
+  async selectPosition(position?: string): Promise<void> {
+    // 点击岗位名称输入框打开下拉列表
+    await this.page.locator('uni-view:nth-child(6) > .nut-cell__value > .nut-form-item__body__slots > .nut-input > .nut-input__value > .nut-input__mask').click();
+    await this.page.waitForTimeout(500);
+    
+    if (position) {
+      // 选择指定岗位
+      await this.page.locator('uni-view').filter({ hasText: position }).first().click();
+    } else {
+      // 随机选择岗位 - 获取所有岗位选项并随机选择一个
+      const options = this.page.locator('uni-view').filter({ hasText: /^销售员$|^仓库管理员$/ });
+      const count = await options.count();
+      if (count > 0) {
+        const randomIndex = Math.floor(Math.random() * count);
+        await options.nth(randomIndex).click();
+      }
+    }
+    await this.page.waitForTimeout(300);
+  }
+
+  /**
+   * 点击确定按钮
+   */
+  async clickConfirm(): Promise<void> {
+    await this.confirmButton.click();
+    await this.page.waitForTimeout(1000);
+  }
+
+  /**
+   * 搜索员工
+   * @param name 员工姓名
+   */
+  async searchEmployee(name: string): Promise<void> {
+    await this.page.getByRole('textbox').click();
+    await this.page.getByRole('textbox').fill(name);
+    await this.page.waitForTimeout(1000);
+  }
+
+  /**
+   * 验证员工是否存在
+   * @param name 员工姓名
+   * @returns 是否存在
+   */
+  async verifyEmployeeExists(name: string): Promise<boolean> {
+    const isVisible = await this.page.getByText(name).first().isVisible().catch(() => false);
+    return isVisible;
+  }
+
+  /**
+   * 新增员工完整流程
+   * @param name 员工姓名
+   * @param phone 联系电话
+   * @param remark 备注
+   * @param position 岗位（可选）
+   */
+  async createEmployee(name: string, phone: string, remark: string, position?: string): Promise<void> {
+    await this.openEmployeeManagement();
+    await this.clickNewEmployee();
+    await this.clickManualAdd();
+    await this.fillEmployeeName(name);
+    await this.fillPhone(phone);
+    await this.fillRemark(remark);
+    await this.selectPosition(position);
+    await this.clickConfirm();
+  }
+
+  /**
+   * 点击修改按钮
+   */
+  async clickEditButton(): Promise<void> {
+    await this.page.locator('uni-button.execute-plain-btn').getByText('修改').click();
+    await this.page.waitForTimeout(500);
+  }
+
+  /**
+   * 填写备注（修改页面）
+   * @param remark 备注信息
+   */
+  async fillRemarkForEdit(remark: string): Promise<void> {
+    await this.page.locator('uni-input').filter({ hasText: '请输入备注信息' }).getByRole('textbox').click();
+    await this.page.locator('uni-input').filter({ hasText: '请输入备注信息' }).getByRole('textbox').fill(remark);
+  }
+
+  /**
+   * 点击状态开关
+   */
+  async clickStatusSwitch(): Promise<void> {
+    await this.page.locator('uni-view:nth-child(5) > .nut-cell__value > .nut-form-item__body__slots > .nut-switch > .nut-switch-button').click();
+    await this.page.waitForTimeout(300);
+  }
+
+  /**
+   * 选择岗位（修改页面）
+   * @param position 岗位名称
+   */
+  async selectPositionForEdit(position: string): Promise<void> {
+    // 点击岗位名称输入框打开下拉列表（使用与新增相同的selector）
+    await this.page.locator('uni-view:nth-child(6) > .nut-cell__value > .nut-form-item__body__slots > .nut-input > .nut-input__value > .nut-input__mask').click();
+    await this.page.waitForTimeout(500);
+    // 选择岗位
+    await this.page.locator('uni-view').filter({ hasText: position }).first().click();
+    await this.page.waitForTimeout(300);
+  }
+
+  /**
+   * 验证员工备注是否包含指定内容
+   * @param expectedRemark 期望的备注内容
+   * @returns 是否包含
+   */
+  async verifyEmployeeRemarkContains(expectedRemark: string): Promise<boolean> {
+    const remarkElement = this.page.getByText(expectedRemark).first();
+    const isVisible = await remarkElement.isVisible({ timeout: 3000 }).catch(() => false);
+    return isVisible;
+  }
+
+  /**
+   * 点击解绑按钮
+   */
+  async clickUnbindButton(): Promise<void> {
+    await this.page.locator('uni-button.warning-plain-btn').getByText('解绑').click();
+    await this.page.waitForTimeout(500);
+  }
+
+  /**
+   * 确认解绑
+   */
+  async confirmUnbind(): Promise<void> {
+    await this.page.getByText('确定', { exact: true }).click();
+    await this.page.waitForTimeout(1000);
+  }
+
+  /**
+   * 验证员工不存在
+   * @param name 员工姓名
+   * @returns 是否不存在
+   */
+  async verifyEmployeeNotExists(name: string): Promise<boolean> {
+    const employeeElement = this.page.getByText(name).first();
+    const isHidden = await employeeElement.isHidden({ timeout: 3000 }).catch(() => true);
+    return isHidden;
+  }
+}
+import { Page, Locator, expect } from '@playwright/test';
+import { BasePage } from './basePage';
+
+/**
+ * 商品分类页面选择器
+ */
+const selectors = {
+  // 导航
+  moreMenu: 'text=更多 >',
+  categoryMenu: 'text=商品分类',
+  
+  // 功能按钮
+  addCategoryButton: 'text=新增分类',
+  editCategoryButton: 'text=修改分类',
+  confirmButton: 'text=确定',
+  clearSearchButton: '.nut-searchbar__search-icon',
+  
+  // 表单
+  categoryNameInput: 'textbox',
+  categoryDescriptionInput: 'textbox',
+  categoryStatusSwitch: '.nut-switch > .nut-switch-button',
+  
+  // 搜索
+  searchInput: 'textbox',
+  
+  // 列表
+  categoryItem: (categoryName: string) => `span:has-text("${categoryName}")`,
+};
+
+/**
+ * 商品分类页面类
+ * 处理商品分类相关操作
+ */
+export class ProductCategoryPage extends BasePage {
+  // 导航定位器
+  readonly moreMenu: Locator;
+  readonly categoryMenu: Locator;
+  
+  // 功能按钮
+  readonly addCategoryButton: Locator;
+  readonly editCategoryButton: Locator;
+  readonly deleteCategoryButton: Locator;
+  readonly confirmButton: Locator;
+  readonly clearSearchButton: Locator;
+  
+  // 表单定位器
+  readonly categoryNameInput: Locator;
+  readonly categoryDescriptionInput: Locator;
+  readonly categoryStatusSwitch: Locator;
+  
+  // 搜索
+  readonly searchInput: Locator;
+
+  constructor(page: Page) {
+    super(page);
+    
+    this.moreMenu = page.getByText('更多 >');
+    this.categoryMenu = page.getByText('商品分类').first();
+    this.addCategoryButton = page.getByText('新增分类');
+    this.editCategoryButton = page.getByText('修改分类');
+    this.deleteCategoryButton = page.getByText('删除分类');
+    this.confirmButton = page.getByText('确定', { exact: true });
+    this.clearSearchButton = page.locator('uni-view:nth-child(7) > .default-container > uni-view > .z-paging-content > .nut-searchbar > .nut-searchbar__search-input > .nut-searchbar__input-inner-icon > .nut-searchbar__search-icon > .nut-icon');
+    this.categoryNameInput = page.getByRole('textbox').nth(1);
+    this.categoryDescriptionInput = page.getByRole('textbox').nth(2);
+    this.categoryStatusSwitch = page.locator('.uni-scroll-view-content > uni-view:nth-child(3) > .nut-cell__value > .nut-form-item__body__slots > .nut-switch > .nut-switch-button');
+    this.searchInput = page.getByRole('textbox').first();
+  }
+
+  /**
+   * 打开商品分类管理页面
+   * 完整流程：首页 -> 更多 -> 商品分类
+   */
+  async openProductCategoryManagement(): Promise<void> {
+    await this.navigate('/');
+    await this.moreMenu.click();
+    await this.page.waitForTimeout(500);
+    await this.categoryMenu.click();
+    await this.page.waitForLoadState('networkidle', { timeout: 30000 });
+  }
+
+  /**
+   * 点击新增分类按钮
+   */
+  async clickAddCategory(): Promise<void> {
+    await this.addCategoryButton.click();
+  }
+
+  /**
+   * 输入分类名称
+   * @param categoryName 分类名称
+   */
+  async enterCategoryName(categoryName: string): Promise<void> {
+    await this.categoryNameInput.click();
+    await this.categoryNameInput.fill(categoryName);
+  }
+
+  /**
+   * 输入分类描述
+   * @param description 分类描述
+   */
+  async enterCategoryDescription(description: string): Promise<void> {
+    await this.categoryDescriptionInput.click();
+    await this.categoryDescriptionInput.fill(description);
+  }
+
+  /**
+   * 点击确定按钮
+   */
+  async clickConfirm(): Promise<void> {
+    await this.confirmButton.click();
+  }
+
+  /**
+   * 搜索分类
+   * @param categoryName 分类名称
+   */
+  async searchCategory(categoryName: string): Promise<void> {
+    await this.searchInput.click();
+    await this.searchInput.fill(categoryName);
+  }
+
+  /**
+   * 验证分类是否存在
+   * @param categoryName 分类名称
+   */
+  async expectCategoryVisible(categoryName: string): Promise<void> {
+    await expect(this.page.locator('span').filter({ hasText: categoryName })).toBeVisible();
+  }
+
+  /**
+   * 创建新商品分类（完整流程）
+   * @param categoryName 分类名称
+   * @param description 分类描述
+   */
+  async createCategory(categoryName: string, description: string): Promise<void> {
+    await this.openProductCategoryManagement();
+    await this.clickAddCategory();
+    await this.enterCategoryName(categoryName);
+    await this.enterCategoryDescription(description);
+    await this.clickConfirm();
+    await this.searchCategory(categoryName);
+    await this.expectCategoryVisible(categoryName);
+  }
+
+  /**
+   * 点击修改分类按钮
+   */
+  async clickEditCategory(): Promise<void> {
+    await this.editCategoryButton.click();
+  }
+
+  /**
+   * 清除搜索框内容
+   */
+  async clearSearch(): Promise<void> {
+    await this.searchInput.click();
+    await this.searchInput.selectText();
+    await this.searchInput.fill('');
+    await this.page.waitForTimeout(300);
+  }
+
+  /**
+   * 切换分类状态
+   */
+  async toggleCategoryStatus(): Promise<void> {
+    await this.categoryStatusSwitch.click();
+  }
+
+  /**
+   * 修改商品分类（完整流程）
+   * @param oldCategoryName 原分类名称
+   * @param newCategoryName 新分类名称
+   * @param newDescription 新描述
+   * @param toggleStatus 是否切换状态
+   */
+  async updateCategory(oldCategoryName: string, newCategoryName: string, newDescription: string, toggleStatus: boolean = false): Promise<void> {
+    // 搜索原分类
+    await this.searchCategory(oldCategoryName);
+    await this.expectCategoryVisible(oldCategoryName);
+    
+    // 点击修改分类
+    await this.clickEditCategory();
+    
+    // 编辑分类信息
+    await this.enterCategoryName(newCategoryName);
+    await this.enterCategoryDescription(newDescription);
+    
+    // 切换状态（可选）
+    if (toggleStatus) {
+      await this.toggleCategoryStatus();
+    }
+    
+    // 点击保存
+    await this.clickConfirm();
+    
+    // 清除搜索框并搜索新分类名
+    await this.clearSearch();
+    await this.searchCategory(newCategoryName);
+    await this.expectCategoryVisible(newCategoryName);
+  }
+
+  /**
+   * 点击删除分类按钮
+   */
+  async clickDeleteCategory(): Promise<void> {
+    await this.deleteCategoryButton.click();
+  }
+
+  /**
+   * 验证分类已删除（不存在）
+   * @param categoryName 分类名称
+   */
+  async expectCategoryNotVisible(categoryName: string): Promise<void> {
+    await expect(this.page.locator('span').filter({ hasText: categoryName })).not.toBeVisible();
+  }
+
+  /**
+   * 删除商品分类（完整流程）
+   * @param categoryName 分类名称
+   */
+  async deleteCategory(categoryName: string): Promise<void> {
+    // 搜索要删除的分类
+    await this.searchCategory(categoryName);
+    await this.expectCategoryVisible(categoryName);
+    
+    // 点击删除分类
+    await this.clickDeleteCategory();
+    
+    // 确认删除
+    await this.clickConfirm();
+    
+    // 等待删除完成
+    await this.page.waitForTimeout(1000);
+    
+    // 验证分类已删除
+    await this.expectCategoryNotVisible(categoryName);
+  }
+}
+import { Page, Locator, expect } from '@playwright/test';
+import { BasePage } from './basePage';
+
+/**
+ * 采购入库页面选择器
+ */
+const selectors = {
+  // 导航
+  moreMenu: 'text=更多 >',
+  purchaseInMenu: 'text=采购入库',
+  
+  // 商品列表
+  goodsList: '.goods-list',
+  goodsItem: '.goods-item',
+  goodsName: '.goods-name span',
+  
+  // 商品选择
+  productItem: (productName: string) => `uni-view:hasText("/^${productName}$/")`,
+  unitBox: 'uni-view:hasText("/^箱$/")',
+  quantityInput: "getByText('1', { exact: true })",
+  priceInput: "getByText('1', { exact: true })",
+  doneButton: 'text=完成',
+  
+  // 供应商列表
+  supplierField: 'uni-view:nth-child(5) > .nut-cell__value > .nut-form-item__body__slots > .nut-input > .nut-input__value > .nut-input__mask',
+  supplierList: '.zp-paging-container-content',
+  supplierItem: '.item-card',
+  supplierName: '.mainTitle span',
+  supplierOption: (supplierName: string) => `uni-view:hasText("/^${supplierName}$/")`,
+  
+  // 仓库列表
+  warehouseField: 'uni-view:nth-child(6) > .nut-cell__value > .nut-form-item__body__slots > .nut-input > .nut-input__value > .nut-input__mask',
+  warehouseList: '.zp-paging-container-content',
+  warehouseItem: '.list-item',
+  warehouseName: '.name',
+  warehouseOption: 'text=东区普通仓库',
+  
+  // 草稿操作
+  saveDraftButton: 'text=存入草稿',
+  draftListButton: 'text=草稿单列表',
+  
+  // 草稿箱搜索
+  draftSearchInput: '.draft-list-wrapper > .z-paging-content > .nut-searchbar > .nut-searchbar__search-input > .nut-searchbar__input-inner > .nut-searchbar__input-form > span > .nut-searchbar__input-bar > .uni-input-wrapper > .uni-input-input',
+  draftItem: 'span',
+};
+
+/**
+ * 采购入库页面类
+ * 处理采购入库草稿相关操作
+ */
+export class PurchasePage extends BasePage {
+  // 导航定位器
+  readonly moreMenu: Locator;
+  readonly purchaseInMenu: Locator;
+  
+  // 商品列表
+  readonly goodsList: Locator;
+  readonly goodsItem: Locator;
+  readonly goodsName: Locator;
+  
+  // 商品选择
+  readonly quantityInput: Locator;
+  readonly priceInput: Locator;
+  readonly doneButton: Locator;
+  
+  // 供应商
+  readonly supplierField: Locator;
+  readonly supplierList: Locator;
+  readonly supplierItem: Locator;
+  readonly supplierName: Locator;
+  
+  // 仓库
+  readonly warehouseField: Locator;
+  readonly warehouseList: Locator;
+  readonly warehouseItem: Locator;
+  readonly warehouseName: Locator;
+  
+  // 草稿操作
+  readonly saveDraftButton: Locator;
+  readonly draftListButton: Locator;
+  
+  // 草稿箱搜索
+  readonly draftSearchInput: Locator;
+  
+  // 费用相关
+  readonly addExpenseButton: Locator;
+  readonly expenseItem: Locator;
+  readonly amountInput: Locator;
+  readonly costItem: Locator;
+  readonly settlementAccountField: Locator;
+  readonly settlementAccountOption: Locator;
+  
+  // 采购员
+  readonly purchaserField: Locator;
+  readonly purchaserItem: Locator;
+  
+  // 车牌号
+  readonly licensePlateInput: Locator;
+  
+  // 备注
+  readonly remarkInput: Locator;
+  
+  // 图片上传
+  readonly uploadImageButton: Locator;
+
+  // 保存
+  readonly saveButton: Locator;
+
+  // 付款
+  readonly payButton: Locator;
+  readonly settlementAccount: Locator;
+  readonly confirmDialogButton: Locator;
+  
+  // 采购列表
+  readonly purchaseListMenu: Locator;
+  readonly purchaseSearchInput: Locator;
+
+  // 复制创建
+  readonly copyCreateButton: Locator;
+
+  // 货款小计
+  readonly subtotalField: Locator;
+
+  // 存储温度
+  readonly storageTemperatureInput: Locator;
+
+  // 编辑修改
+  readonly editButton: Locator;
+
+  // 入账日期
+  readonly entryDateField: Locator;
+
+  // 批次别名
+  readonly batchAliasInput: Locator;
+  readonly batchAliasClearIcon: Locator;
+
+  // 取消
+  readonly cancelButton: Locator;
+  readonly cancelConfirmButton: Locator;
+
+  // 撤销
+  readonly revokeButton: Locator;
+
+  constructor(page: Page) {
+    super(page);
+    
+    this.moreMenu = page.getByText('更多 >');
+    this.purchaseInMenu = page.getByText('采购入库').first();
+    this.goodsList = page.locator('.goods-list');
+    this.goodsItem = page.locator('.goods-item');
+    this.goodsName = page.locator('.goods-name span');
+    this.quantityInput = page.locator('[data-prop="num1"] .input');
+    this.priceInput = page.locator('[data-prop="unitPrice"] .input');
+    this.doneButton = page.getByText('完成');
+    this.supplierField = page.locator('uni-view:nth-child(5) > .nut-cell__value > .nut-form-item__body__slots > .nut-input > .nut-input__value > .nut-input__mask');
+    this.supplierList = page.locator('.zp-paging-container-content').first();
+    this.supplierItem = page.locator('.item-card');
+    this.supplierName = page.locator('.mainTitle span');
+    this.warehouseField = page.locator('uni-view:nth-child(6) > .nut-cell__value > .nut-form-item__body__slots > .nut-input > .nut-input__value > .nut-input__mask');
+    this.warehouseList = page.locator('.zp-paging-container-content').first();
+    this.warehouseItem = page.locator('.list-item');
+    this.warehouseName = page.locator('.name');
+    this.saveDraftButton = page.getByText('存入草稿', { exact: true });
+    this.draftListButton = page.getByText('草稿单列表', { exact: true });
+    this.draftSearchInput = page.locator('.draft-list-wrapper > .z-paging-content > .nut-searchbar > .nut-searchbar__search-input > .nut-searchbar__input-inner > .nut-searchbar__input-form > span > .nut-searchbar__input-bar > .uni-input-wrapper > .uni-input-input');
+    
+    // 费用相关
+    this.addExpenseButton = page.getByText('入库费用添加费用');
+    this.expenseItem = page.locator('.account-item');
+    this.amountInput = page.locator('.cost-item > uni-view:nth-child(3) > .nut-cell__value > .nut-form-item__body__slots > .nut-input > .nut-input__value > .nut-input__mask');
+    this.costItem = page.locator('.cost-item');
+    this.settlementAccountField = page.locator('.cost-item > uni-view:nth-child(6) > .nut-cell__value > .nut-form-item__body__slots > .nut-input > .nut-input__value > .nut-input__mask');
+    this.settlementAccountOption = page.locator('uni-view').filter({ hasText: /^现金$/ }).first();
+    
+    // 采购员
+    this.purchaserField = page.locator('uni-view:nth-child(10) > .nut-cell__value > .nut-form-item__body__slots > .nut-input > .nut-input__value > .nut-input__mask');
+    this.purchaserItem = page.locator('.list > .item');
+    
+    // 车牌号 - 使用nth-child(11)
+    this.licensePlateInput = page.locator('uni-view:nth-child(11) > .nut-cell__value > .nut-form-item__body__slots > .nut-input > .nut-input__value > .nut-input__mask');
+    
+    // 备注 - 使用nth-child(12)
+    this.remarkInput = page.locator('uni-view:nth-child(12) > .nut-cell__value > .nut-form-item__body__slots > .nut-input > .nut-input__value > .nut-input__input > .uni-input-wrapper > .uni-input-input');
+    
+    // 图片上传
+    this.uploadImageButton = page.getByText('图片（最多上传9张）');
+
+    // 保存
+    this.saveButton = page.getByText('保存', { exact: true });
+
+    // 付款
+    this.payButton = page.getByText('付款', { exact: true });
+    this.settlementAccount = page.locator('uni-view').filter({ hasText: /^微信支付$/ }).first();
+    this.confirmDialogButton = page.getByText('确定').first();
+    
+    // 采购列表
+    this.purchaseListMenu = page.getByText('采购列表');
+    this.purchaseSearchInput = page.getByRole('textbox');
+
+    // 复制创建
+    this.copyCreateButton = page.getByText('复制创建');
+
+    // 货款小计
+    this.subtotalField = page.locator('uni-view:nth-child(2) > .nut-cell__value > .nut-form-item__body__slots > .nut-input > .nut-input__value > .nut-input__mask');
+
+    // 存储温度
+    this.storageTemperatureInput = page.locator('uni-view:nth-child(9) > .nut-cell__value > .nut-form-item__body__slots > .nut-input > .nut-input__value > .nut-input__input > .uni-input-wrapper > .uni-input-input');
+
+    // 编辑修改
+    this.editButton = page.getByText('修改', { exact: true });
+
+    // 入账日期
+    this.entryDateField = page.locator('uni-view:nth-child(7) > .nut-cell__value > .nut-form-item__body__slots > .nut-input > .nut-input__value > .nut-input__mask');
+
+    // 批次别名
+    this.batchAliasInput = page.locator('uni-view:nth-child(8) > .nut-cell__value > .nut-form-item__body__slots > .nut-input > .nut-input__value > .nut-input__input > .uni-input-wrapper > .uni-input-input');
+    this.batchAliasClearIcon = page.locator('uni-view:nth-child(8) > .nut-cell__value > .nut-form-item__body__slots > .nut-input > .nut-input__clear > .nut-input__clear-icon');
+
+    // 取消
+    this.cancelButton = page.getByText('取消', { exact: true });
+    this.cancelConfirmButton = page.getByText('确定', { exact: true });
+
+    // 撤销
+    this.revokeButton = page.getByText('撤销', { exact: true });
+  }
+
+  /**
+   * 进入采购入库页面
+   */
+  async openPurchaseInbound(): Promise<void> {
+    await this.navigate('/');
+    await this.moreMenu.click();
+    await this.page.waitForTimeout(500);
+    await this.purchaseInMenu.click();
+    await this.page.waitForLoadState('networkidle', { timeout: 30000 });
+  }
+
+  /**
+   * 从商品列表随机选择一个商品
+   * @returns 商品名称和索引
+   */
+  async getRandomProduct(): Promise<{ name: string; index: number }> {
+    // 等待商品列表加载
+    await this.goodsList.waitFor({ state: 'visible', timeout: 10000 });
+    await this.page.waitForTimeout(500);
+    
+    // 获取所有商品名称
+    const productNames = await this.goodsName.allTextContents();
+    if (productNames.length === 0) {
+      throw new Error('商品列表为空');
+    }
+    
+    // 随机选择一个商品
+    const randomIndex = Math.floor(Math.random() * productNames.length);
+    const selectedProduct = productNames[randomIndex];
+    console.log('随机选择的商品:', selectedProduct, '索引:', randomIndex);
+    
+    return { name: selectedProduct, index: randomIndex };
+  }
+
+  /**
+   * 选择商品（从商品列表随机选择）
+   * @returns 商品名称
+   */
+  async selectRandomProduct(): Promise<string> {
+    const { name, index } = await this.getRandomProduct();
+    await this.goodsItem.nth(index).click();
+    await this.page.waitForTimeout(300);
+    return name;
+  }
+
+  /**
+   * 选择指定商品
+   * @param productName 商品名称
+   */
+  async selectProduct(productName: string): Promise<void> {
+    await this.page.locator('uni-view').filter({ hasText: new RegExp(`^${productName}$`) }).first().click();
+  }
+
+  /**
+   * 点击数量输入框（通过data-prop属性定位）
+   */
+  async clickQuantityInput(): Promise<void> {
+    await this.quantityInput.click();
+  }
+
+  /**
+   * 输入数量
+   * @param quantity 数量
+   */
+  async enterQuantity(quantity: string): Promise<void> {
+    // 点击数量输入框（通过data-prop属性定位）
+    await this.page.locator('[data-prop="num1"]').click();
+    // 点击键盘上的数字
+    await this.page.locator(`.number-keyboard uni-view[data-key="${quantity}"]`).click();
+  }
+
+  /**
+   * 输入单价（点击单价输入框，然后点击键盘数字）
+   * @param price 单价
+   */
+  async enterPrice(price: string): Promise<void> {
+    // 点击单价输入框（通过data-prop属性定位，不依赖单位文本）
+    await this.page.locator('[data-prop="unitPrice"]').click();
+    // 点击键盘上的数字
+    await this.page.locator(`.number-keyboard uni-view[data-key="${price}"]`).click();
+  }
+
+  /**
+   * 点击完成按钮
+   */
+  async clickDone(): Promise<void> {
+    await this.doneButton.click();
+    await this.page.waitForTimeout(1000);
+  }
+
+  /**
+   * 从供应商列表随机选择供应商
+   * @returns 供应商名称
+   */
+  async getRandomSupplier(): Promise<string> {
+    await this.supplierField.click();
+    await this.page.waitForTimeout(1000);
+    
+    const supplierNames = await this.supplierName.allTextContents();
+    if (supplierNames.length === 0) {
+      throw new Error('供应商列表为空');
+    }
+    
+    const randomIndex = Math.floor(Math.random() * supplierNames.length);
+    const selectedSupplier = supplierNames[randomIndex];
+    console.log('随机选择的供应商:', selectedSupplier, '索引:', randomIndex);
+    
+    await this.supplierItem.nth(randomIndex).click();
+    await this.page.waitForTimeout(300);
+    
+    return selectedSupplier;
+  }
+
+  /**
+   * 选择指定供应商
+   * @param supplierName 供应商名称
+   */
+  async selectSupplier(supplierName: string): Promise<void> {
+    await this.supplierField.click();
+    await this.page.locator('uni-view').filter({ hasText: new RegExp(`^${supplierName}$`) }).nth(1).click();
+  }
+
+  /**
+   * 从仓库列表随机选择仓库
+   * @returns 仓库名称
+   */
+  async getRandomWarehouse(): Promise<string> {
+    await this.warehouseField.click();
+    await this.page.waitForTimeout(1000);
+    
+    const warehouseNames = await this.warehouseName.allTextContents();
+    if (warehouseNames.length === 0) {
+      throw new Error('仓库列表为空');
+    }
+    
+    const randomIndex = Math.floor(Math.random() * warehouseNames.length);
+    const selectedWarehouse = warehouseNames[randomIndex];
+    console.log('随机选择的仓库:', selectedWarehouse, '索引:', randomIndex);
+    
+    await this.warehouseItem.nth(randomIndex).click();
+    await this.page.waitForTimeout(300);
+    
+    return selectedWarehouse;
+  }
+
+  /**
+   * 选择指定仓库
+   * @param warehouseName 仓库名称
+   */
+  async selectWarehouse(warehouseName: string): Promise<void> {
+    await this.warehouseField.click();
+    await this.page.getByText(warehouseName).nth(2).click();
+  }
+
+  /**
+   * 点击存入草稿
+   */
+  async clickSaveDraft(): Promise<void> {
+    await this.saveDraftButton.click();
+  }
+
+  /**
+   * 点击草稿单列表
+   */
+  async clickDraftList(): Promise<void> {
+    await this.draftListButton.click();
+    await this.page.waitForLoadState('networkidle', { timeout: 30000 });
+  }
+
+  /**
+   * 在草稿箱搜索商品
+   * @param productName 商品名称
+   */
+  async searchInDraftList(productName: string): Promise<void> {
+    await this.draftSearchInput.click();
+    await this.draftSearchInput.fill(productName);
+  }
+
+  /**
+   * 验证草稿列表中存在商品
+   * @param productName 商品名称
+   */
+  async expectDraftContainsProduct(productName: string): Promise<void> {
+    // 等待搜索结果加载
+    await this.page.waitForTimeout(500);
+    // 获取列表中第一个商品进行断言
+    const firstItem = this.page.locator('span').filter({ hasText: productName }).first();
+    await expect(firstItem).toBeVisible();
+  }
+
+  /**
+   * 点击保存按钮
+   */
+  async clickSave(): Promise<void> {
+    await this.saveButton.click();
+    await this.page.waitForLoadState('networkidle', { timeout: 30000 });
+    await this.page.waitForTimeout(2000);
+  }
+
+  /**
+   * 点击草稿单列表第一个草稿进入编辑页
+   */
+  async clickDraftProduct(): Promise<void> {
+    await this.page.locator('.draft-card-list > uni-view').first().click();
+    await this.page.waitForLoadState('networkidle', { timeout: 30000 });
+    await this.page.waitForTimeout(1000);
+  }
+
+  /**
+   * 验证采购单状态为待支付
+   * @param productName 商品名称
+   */
+  async expectPurchaseOrderStatusPending(productName: string): Promise<void> {
+    const statusLabel = this.page.getByText('待支付').nth(1);
+    await expect(statusLabel).toBeVisible({ timeout: 10000 });
+  }
+
+  /**
+   * 验证采购单状态为已支付
+   */
+  async expectPurchaseOrderStatusPaid(): Promise<void> {
+    const statusLabel = this.page.getByText('已支付').nth(1);
+    await expect(statusLabel).toBeVisible({ timeout: 10000 });
+  }
+
+  /**
+   * 点击取消按钮
+   */
+  async clickCancelButton(): Promise<void> {
+    await this.cancelButton.click();
+    await this.page.waitForTimeout(500);
+  }
+
+  /**
+   * 确认取消弹窗
+   */
+  async confirmCancelDialog(): Promise<void> {
+    await this.cancelConfirmButton.click();
+    await this.page.waitForTimeout(1000);
+  }
+
+  /**
+   * 点击撤销按钮
+   */
+  async clickRevokeButton(): Promise<void> {
+    await this.revokeButton.click();
+    await this.page.waitForTimeout(500);
+  }
+
+  /**
+   * 验证采购单状态为已取消
+   */
+  async expectPurchaseOrderStatusCancelled(): Promise<void> {
+    const statusLabel = this.page.locator('uni-text').filter({ hasText: '已取消' }).first();
+    await expect(statusLabel).toBeVisible({ timeout: 10000 });
+  }
+
+  /**
+   * 验证采购单状态为已撤销
+   */
+  async expectPurchaseOrderStatusRevoked(): Promise<void> {
+    const statusLabel = this.page.locator('uni-text').filter({ hasText: '已撤销' }).first();
+    await expect(statusLabel).toBeVisible({ timeout: 10000 });
+  }
+
+  /**
+   * 创建采购入库草稿（完整流程）
+   * @param productName 商品名称
+   * @param supplierName 供应商名称
+   * @param warehouseName 仓库名称
+   * @param quantity 数量
+   * @param price 单价
+   */
+  async createPurchaseDraft(productName: string, supplierName: string, warehouseName: string, quantity: string = '1', price: string = '1'): Promise<void> {
+    // 选择商品
+    await this.selectProduct(productName);
+    
+    // 输入数量
+    await this.enterQuantity(quantity);
+    
+    // 输入单价
+    await this.enterPrice(price);
+    
+    // 点击完成
+    await this.clickDone();
+    
+    // 选择供应商
+    await this.selectSupplier(supplierName);
+    
+    // 选择仓库
+    await this.selectWarehouse(warehouseName);
+    
+    // 存入草稿
+    await this.clickSaveDraft();
+    
+    // 打开草稿单列表
+    await this.clickDraftList();
+    
+    // 搜索商品
+    await this.searchInDraftList(productName);
+    
+    // 验证商品存在
+    await this.expectDraftContainsProduct(productName);
+  }
+
+  /**
+   * 添加入库费用
+   * @param expenseIndex 费用项索引（默认0）
+   * @param amount 金额（默认'1'）
+   */
+  async addExpense(expenseIndex: number = 0, amount: string = '1'): Promise<void> {
+    // 打开费用选择
+    await this.addExpenseButton.click();
+    
+    // 等待费用列表加载
+    await this.page.waitForTimeout(500);
+    
+    // 随机选择费用项
+    const expenseCount = await this.expenseItem.count();
+    const randomIndex = Math.floor(Math.random() * expenseCount);
+    await this.expenseItem.nth(randomIndex).click();
+    await this.page.getByText('确定').click();
+    
+    // 输入金额 - 点击金额输入框，然后点击键盘数字
+    await this.amountInput.click();
+    await this.page.waitForTimeout(300);
+    await this.page.getByText('1', { exact: true }).click();
+    
+    // 点击键盘上的完成按钮关闭键盘
+    await this.page.getByText('完成', { exact: true }).click();
+    
+    // 点击结算账户并选择现金
+    await this.settlementAccountField.click();
+    await this.page.waitForTimeout(300);
+    await this.settlementAccountOption.click();
+    
+    // 点击确定按钮
+    await this.page.getByText('确定').click();
+  }
+
+  /**
+   * 选择采购员
+   * @param purchaserName 采购员名称
+   */
+  async selectPurchaser(purchaserName?: string): Promise<string> {
+    await this.purchaserField.click();
+    await this.page.waitForTimeout(500);
+    
+    // 如果没有指定采购员，随机选择
+    if (!purchaserName) {
+      const purchasers = await this.purchaserItem.locator('.name').allTextContents();
+      if (purchasers.length === 0) {
+        throw new Error('采购员列表为空');
+      }
+      const randomIndex = Math.floor(Math.random() * purchasers.length);
+      purchaserName = purchasers[randomIndex];
+      await this.purchaserItem.nth(randomIndex).click();
+    } else {
+      await this.page.locator('uni-view').filter({ hasText: new RegExp(`^${purchaserName}`) }).first().click();
+    }
+    
+    await this.page.waitForTimeout(300);
+    return purchaserName;
+  }
+
+  /**
+   * 输入车牌号
+   * @param licensePlate 车牌号
+   */
+  async enterLicensePlate(licensePlate: string): Promise<void> {
+    await this.fillLicensePlate(licensePlate, this.licensePlateInput);
+  }
+
+  /**
+   * 输入备注
+   * @param remark 备注内容
+   */
+  async enterRemark(remark: string): Promise<void> {
+    await this.remarkInput.click();
+    await this.remarkInput.fill(remark);
+  }
+
+  /**
+   * 上传图片
+   * @param imagePath 图片路径
+   */
+  async uploadImage(imagePath: string): Promise<void> {
+    // 点击图片上传区域
+    await this.uploadImageButton.click();
+    await this.page.waitForTimeout(500);
+    // 点击上传按钮
+    await this.page.locator('span').filter({ hasText: '供应商*请选择供应商车牌号请选择车牌号入库日期*请选择入库日期入库仓库*请选择仓库批次别名*请输入批次别名备注请输入备注商品清单点击选择商品入库费用添加费用存储' }).locator('uni-button').click();
+    await this.page.waitForTimeout(300);
+    // 点击上传input
+    await this.page.locator('.nut-uploader__input').click();
+    // 使用 setInputFiles 方式上传
+    await this.page.locator('body').setInputFiles(imagePath);
+  }
+
+  /**
+   * 点击付款按钮
+   * @param index 第几个付款按钮，默认0（表单页），列表页使用1
+   */
+  async clickPay(index: number = 0): Promise<void> {
+    await this.payButton.nth(index).click();
+  }
+
+  /**
+   * 选择结算账户
+   * @param accountName 账户名称（默认微信支付）
+   */
+  async selectSettlementAccount(accountName: string = '微信支付'): Promise<void> {
+    await this.settlementAccount.filter({ hasText: new RegExp(`^${accountName}$`) }).click();
+  }
+
+  /**
+   * 确认付款弹窗
+   */
+  async confirmPayment(): Promise<void> {
+    // 等待确认弹窗出现
+    await this.confirmDialogButton.waitFor({ state: 'visible', timeout: 10000 });
+    await this.confirmDialogButton.click();
+    await this.page.waitForTimeout(1000);
+  }
+
+  /**
+   * 进入采购列表
+   */
+  async goToPurchaseList(): Promise<void> {
+    await this.purchaseListMenu.click();
+    await this.page.waitForLoadState('networkidle', { timeout: 30000 });
+    await this.page.waitForTimeout(2000);
+  }
+
+  /**
+   * 点击复制创建按钮
+   */
+  async clickCopyCreate(): Promise<void> {
+    await this.copyCreateButton.click();
+    await this.page.waitForLoadState('networkidle', { timeout: 30000 });
+    await this.page.waitForTimeout(1000);
+  }
+
+  /**
+   * 点击货款小计输入框（触发键盘）
+   */
+  async clickSubtotal(): Promise<void> {
+    await this.subtotalField.click();
+    await this.page.waitForTimeout(500);
+  }
+
+  /**
+   * 输入货款小计金额（通过数字键盘）
+   * @param amount 金额
+   */
+  async enterSubtotalAmount(amount: string): Promise<void> {
+    await this.page.locator(`.number-keyboard uni-view[data-key="${amount}"]`).click();
+    await this.page.waitForTimeout(300);
+    await this.page.getByText('完成').click();
+    await this.page.waitForTimeout(500);
+  }
+
+  /**
+   * 输入存储温度
+   * @param value 温度值
+   */
+  async enterStorageTemperature(value: string): Promise<void> {
+    await this.storageTemperatureInput.click();
+    await this.storageTemperatureInput.fill(value);
+  }
+
+  /**
+   * 在采购列表搜索商品
+   * @param productName 商品名称
+   */
+  async searchInPurchaseList(productName: string): Promise<void> {
+    // 使用 filter 精确定位到商品名称搜索框（避免匹配到供应商搜索框）
+    const searchInput = this.page.locator('uni-input').filter({ hasText: '供应商/商品名称' }).locator('input[type="text"]');
+    await searchInput.waitFor({ state: 'visible', timeout: 10000 });
+    await searchInput.click();
+    await this.page.waitForTimeout(300);
+    await searchInput.fill(productName);
+    await this.page.waitForTimeout(500);
+  }
+
+  /**
+   * 选择入账日期：打开日历 → 翻到上一月 → 选择15号
+   */
+  async selectEntryDate(): Promise<void> {
+    await this.entryDateField.click();
+    await this.page.waitForTimeout(500);
+    await this.page.locator('.uni-calendar__header-btn').first().click();
+    await this.page.waitForTimeout(300);
+    await this.page.locator('uni-view').filter({ hasText: /^15$/ }).nth(2).click();
+    await this.page.waitForTimeout(300);
+  }
+
+  /**
+   * 清除并输入批次别名
+   * @param alias 批次别名
+   */
+  async clearAndEnterBatchAlias(alias: string): Promise<void> {
+    await this.batchAliasInput.click();
+    await this.page.waitForTimeout(300);
+    await this.batchAliasClearIcon.click();
+    await this.page.waitForTimeout(300);
+    await this.batchAliasInput.click();
+    await this.batchAliasInput.fill(alias);
+  }
+
+  /**
+   * 清除采购列表搜索框内容
+   */
+  async clearSearchInPurchaseList(): Promise<void> {
+    const searchInput = this.page.locator('uni-input').filter({ hasText: '供应商/商品名称' }).locator('input[type="text"]');
+    await searchInput.clear();
+    await this.page.waitForTimeout(500);
+  }
+
+  /**
+   * 点击采购列表的修改按钮进入编辑页
+   */
+  async clickEditButton(): Promise<void> {
+    await this.editButton.click();
+    await this.page.waitForLoadState('networkidle', { timeout: 30000 });
+    await this.page.waitForTimeout(1000);
+  }
+
+  /**
+   * 验证采购列表中存在商品
+   * @param productName 商品名称
+   */
+  async expectPurchaseListContainsProduct(productName: string): Promise<void> {
+    // 虚拟列表中元素可能处于 hidden 状态,使用 toBeAttached 而非 toBeVisible
+    const firstItem = this.page.locator('.goods-item').filter({ hasText: productName }).first();
+    await expect(firstItem).toBeAttached();
+  }
+
+  /**
+   * 创建采购入库付款单（完整流程）
+   * @param productName 商品名称
+   * @param supplierName 供应商名称
+   * @param warehouseName 仓库名称
+   * @param quantity 数量
+   * @param price 单价
+   * @param expenseAmount 费用金额
+   * @param purchaserName 采购员名称
+   * @param licensePlate 车牌号
+   * @param remark 备注
+   * @param imagePath 图片路径
+   */
+  async createPurchasePayment(
+    productName: string,
+    supplierName: string,
+    warehouseName: string,
+    quantity: string = '1',
+    price: string = '1',
+    expenseAmount: string = '1',
+    purchaserName?: string,
+    licensePlate?: string,
+    remark: string = '自动化测试',
+    imagePath?: string
+  ): Promise<void> {
+    // 选择商品
+    await this.selectProduct(productName);
+    
+    // 输入数量
+    await this.enterQuantity(quantity);
+    
+    // 输入单价
+    await this.enterPrice(price);
+    
+    // 点击完成
+    await this.clickDone();
+    
+    // 添加入库费用
+    await this.addExpense(0, expenseAmount);
+    
+    // 选择供应商
+    await this.selectSupplier(supplierName);
+    
+    // 选择仓库
+    await this.selectWarehouse(warehouseName);
+    
+    // 选择采购员
+    await this.selectPurchaser(purchaserName);
+    
+    // 输入车牌号
+    if (licensePlate) {
+      await this.enterLicensePlate(licensePlate);
+    }
+    
+    // 输入备注
+    await this.enterRemark(remark);
+    
+    // 上传图片
+    if (imagePath) {
+      await this.uploadImage(imagePath);
+    }
+    
+    // 点击付款
+    await this.clickPay();
+    
+    // 选择结算账户
+    await this.selectSettlementAccount('微信支付');
+    
+    // 确认付款
+    await this.confirmPayment();
+    
+    // 进入采购列表
+    await this.goToPurchaseList();
+    
+    // 搜索商品
+    await this.searchInPurchaseList(productName);
+    
+    // 验证商品存在
+    await this.expectPurchaseListContainsProduct(productName);
+  }
+}
 \ No newline at end of file
@@ -7,7 +7,7 @@ dotenv.config({ path: path.resolve(__dirname, &#39;../.env&#39;) });
  
 const TEST_PHONE = process.env.phone;
 const TEST_USER_NAME = process.env.TEST_USER_NAME;
-const BASE_URL = process.env.BASE_URL || 'https://erp-pad.test.gszdtop.com';
+const BASE_URL = process.env.BASE_URL ;
  
 if (!TEST_PHONE || !TEST_USER_NAME) {
   throw new Error('phone 和 TEST_USER_NAME 环境变量未设置');
+<<<<<<< HEAD
 // import { test, expect } from '@playwright/test';
 // import * as allure from 'allure-js-commons';
  
@@ -102,3 +103,166 @@
 //     });
 //   });
 // });
+=======
+import { test, expect } from '@playwright/test';
+import * as allure from 'allure-js-commons';
+import { AccountPage } from '../pages/accountPage';
+
+/**
+ * 账目管理测试
+ */
+test.describe('账目管理', () => {
+  // 使用已保存的认证状态
+  test.use({ storageState: 'auth.json' });
+
+  // 强制测试串行执行
+  test.describe.configure({ mode: 'serial' });
+
+  /**
+   * 生成随机账目名称（三个字+"费"，带时间戳后缀防止重复）
+   */
+  function generateAccountName(): string {
+    const prefixes = ['管理', '维护', '看管', '保管', '仓储', '代理', '服务', '咨询', '技术', '运营'];
+    const prefix = prefixes[Math.floor(Math.random() * prefixes.length)];
+    const timestamp = Date.now().toString().slice(-4);
+    return `${prefix}费${timestamp}`;
+  }
+
+  /**
+   * 生成随机收支类型
+   */
+  function generateIncomeType(): '收入' | '支出' {
+    return Math.random() > 0.5 ? '收入' : '支出';
+  }
+
+  /**
+   * 生成包含"自动化"的备注
+   */
+  function generateRemark(): string {
+    const timestamp = Date.now().toString().slice(-6);
+    return `自动化测试备注${timestamp}`;
+  }
+
+  test('新增账目', async ({ page }, testInfo) => {
+    const accountPage = new AccountPage(page);
+    
+    // 添加allure元素
+    await allure.epic('账目管理');
+    await allure.feature('账目信息');
+    await allure.story('新增账目');
+
+    // 生成随机账目数据
+    const accountName = generateAccountName();
+    const incomeType = generateIncomeType();
+    const remark = generateRemark();
+    
+    console.log('账目名称:', accountName);
+    console.log('收支类型:', incomeType);
+    console.log('备注:', remark);
+
+    // 步骤1：进入账目管理页面
+    await allure.step('进入账目管理页面', async () => {
+      await accountPage.openAccountManagement();
+    });
+
+    // 步骤2：点击新增按钮
+    await allure.step('点击新增按钮', async () => {
+      await accountPage.clickAddButton();
+    });
+
+    // 步骤3：填写账目表单
+    await allure.step('填写账目表单', async () => {
+      await accountPage.fillAccountName(accountName);
+      await accountPage.selectIncomeType(incomeType);
+      await accountPage.fillRemark(remark);
+    });
+
+    // 步骤4：保存账目
+    await allure.step('保存账目', async () => {
+      await accountPage.saveAccount();
+    });
+
+    // 步骤5：验证账目创建成功
+    await allure.step('验证账目创建成功', async () => {
+      await accountPage.searchAccount(accountName);
+      const isCreated = await accountPage.verifyAccountExists(accountName);
+      expect(isCreated).toBeTruthy();
+    });
+  });
+
+  test('删除账目', async ({ page }, testInfo) => {
+    const accountPage = new AccountPage(page);
+    
+    // 添加allure元素
+    await allure.epic('账目管理');
+    await allure.feature('账目信息');
+    await allure.story('删除账目');
+
+    // 生成随机账目数据
+    const accountName = generateAccountName();
+    console.log('待删除账目名称:', accountName);
+
+    // 步骤1：新增账目
+    await allure.step('新增账目', async () => {
+      await accountPage.openAccountManagement();
+      await accountPage.clickAddButton();
+      await accountPage.fillAccountName(accountName);
+      await accountPage.saveAccount();
+    });
+
+    // 步骤2：删除账目
+    await allure.step('删除账目', async () => {
+      await accountPage.deleteAccount(accountName);
+    });
+
+    // 步骤3：验证账目删除成功
+    await allure.step('验证账目删除成功', async () => {
+      const isDeleted = await accountPage.verifyAccountDeleted(accountName);
+      expect(isDeleted).toBeTruthy();
+    });
+  });
+
+  test('修改账目', async ({ page }, testInfo) => {
+    const accountPage = new AccountPage(page);
+    
+    // 添加allure元素
+    await allure.epic('账目管理');
+    await allure.feature('账目信息');
+    await allure.story('修改账目');
+
+    // 生成随机账目数据
+    const originalName = generateAccountName();
+    const newName = generateAccountName();
+    const incomeType = generateIncomeType();
+    const remark = generateRemark();
+    
+    console.log('原账目名称:', originalName);
+    console.log('新账目名称:', newName);
+    console.log('收支类型:', incomeType);
+    console.log('备注:', remark);
+
+    // 步骤1：新增账目
+    await allure.step('新增账目', async () => {
+      await accountPage.openAccountManagement();
+      await accountPage.clickAddButton();
+      await accountPage.fillAccountName(originalName);
+      await accountPage.saveAccount();
+    });
+
+    // 步骤2：修改账目
+    await allure.step('修改账目', async () => {
+      await accountPage.updateAccount(originalName, newName, incomeType, remark);
+    });
+
+    // 步骤3：验证账目修改成功
+    await allure.step('验证账目修改成功', async () => {
+      // 清除搜索框
+      await accountPage.clearSearchBox();
+      // 搜索修改后的账目名称
+      await accountPage.searchAccount(newName);
+      const isExists = await accountPage.verifyAccountExists(newName);
+      expect(isExists).toBeTruthy();
+    });
+  });
+});
+>>>>>>> xfbhzxt
 import { test, expect } from '@playwright/test';
 import * as allure from 'allure-js-commons';
+import { CustomerGroupPage } from '../pages/customerGroupPage';
  
 /**
  * 客户分组测试
@@ -32,6 +33,8 @@ test.describe(&#39;客户分组&#39;, () =&gt; {
   }
  
   test('新增客户分组', async ({ page }, testInfo) => {
+    const customerGroupPage = new CustomerGroupPage(page);
+    
     // 添加allure元素
     await allure.epic('客户管理');
     await allure.feature('客户分组');
@@ -43,47 +46,34 @@ test.describe(&#39;客户分组&#39;, () =&gt; {
  
     // 步骤1：进入客户分组页面
     await allure.step('进入客户分组页面', async () => {
-      await page.goto('/');
-      await page.waitForLoadState('networkidle', { timeout: 30000 });
-      await page.getByText('更多 >').click();
-      await page.waitForTimeout(500);
-      await page.getByText('客户分组').first().click();
-      await page.waitForLoadState('networkidle', { timeout: 30000 });
+      await customerGroupPage.openCustomerGroupManagement();
     });
  
     // 步骤2：点击新建按钮
     await allure.step('点击新建按钮', async () => {
-      await page.getByText('新建').click();
-      await page.waitForTimeout(500);
+      await customerGroupPage.clickNewButton();
     });
  
     // 步骤3：填写分组信息
     await allure.step('填写分组信息', async () => {
-      // 填写分组名称
-      await page.getByRole('textbox').nth(1).click();
-      await page.getByRole('textbox').nth(1).fill(groupName);
-      
-      // 填写备注/排序
-      await page.getByRole('textbox').nth(2).click();
-      await page.getByRole('textbox').nth(2).fill('自动化测试分组');
+      await customerGroupPage.fillGroupName(groupName);
     });
  
     // 步骤4：保存分组
     await allure.step('保存分组', async () => {
-      await page.getByText('确定').click();
-      await page.waitForTimeout(1000);
+      await customerGroupPage.clickConfirm();
     });
  
-    // 步骤5：验证分组创建成功 - 使用正则匹配检查页面是否出现新增的内容
+    // 步骤5：验证分组创建成功
     await allure.step('验证分组创建成功', async () => {
-      await page.waitForTimeout(1000); // 等待页面刷新
-      // 使用正则匹配分组名称
-      const isGroupVisible = await page.locator('uni-view').filter({ hasText: new RegExp(`^${groupName}$`) }).first().isVisible({ timeout: 5000 }).catch(() => false);
-      expect(isGroupVisible).toBeTruthy();
+      const isExists = await customerGroupPage.verifyGroupExists(groupName);
+      expect(isExists).toBeTruthy();
     });
   });
  
   test('修改客户分组', async ({ page }, testInfo) => {
+    const customerGroupPage = new CustomerGroupPage(page);
+    
     // 添加allure元素
     await allure.epic('客户管理');
     await allure.feature('客户分组');
@@ -92,71 +82,30 @@ test.describe(&#39;客户分组&#39;, () =&gt; {
     // 先生成一个分组用于修改
     const originalGroupName = generateGroupName();
     const newGroupName = generateGroupName();
+    const newSortNumber = generateSortNumber();
     console.log('原分组名称:', originalGroupName);
     console.log('新分组名称:', newGroupName);
  
-    // 步骤1：进入客户分组页面并创建分组
-    await allure.step('进入客户分组页面并创建分组', async () => {
-      await page.goto('/');
-      await page.waitForLoadState('networkidle', { timeout: 30000 });
-      await page.getByText('更多 >').click();
-      await page.waitForTimeout(500);
-      await page.getByText('客户分组').first().click();
-      await page.waitForLoadState('networkidle', { timeout: 30000 });
-      
-      // 创建分组
-      await page.getByText('新建').click();
-      await page.waitForTimeout(500);
-      // 点击分组名称输入框
-      await page.locator('uni-view').filter({ hasText: /^分组名称\*$/ }).first().click();
-      await page.getByRole('textbox').nth(1).fill(originalGroupName);
-      await page.getByText('确定').click();
-      await page.waitForTimeout(1000);
+    // 步骤1：先创建分组
+    await allure.step('创建待修改的分组', async () => {
+      await customerGroupPage.createGroup(originalGroupName);
     });
  
-    // 步骤2：搜索并修改分组
-    await allure.step('搜索并修改分组', async () => {
-      // 在搜索框中输入原分组名称
-      await page.getByRole('textbox').click();
-      await page.getByRole('textbox').fill(originalGroupName);
-      
-      // 点击搜索结果中的分组
-      await page.locator('uni-view').filter({ hasText: new RegExp(`^${originalGroupName}$`) }).first().click();
-      await page.waitForTimeout(500);
-      
-      // 点击编辑按钮
-      await page.getByText('编辑').click();
-      await page.waitForTimeout(500);
-      
-      // 清空分组名称并填写新名称
-      await page.getByRole('textbox').nth(1).click();
-      await page.locator('.nut-input__clear-icon').first().click();
-      await page.getByRole('textbox').nth(1).click();
-      await page.getByRole('textbox').nth(1).fill(newGroupName);
-      
-      // 直接填写新排序号（新增时未填写，无需清除）
-      const newSortNumber = generateSortNumber();
-      await page.getByRole('textbox').nth(2).click();
-      await page.getByRole('textbox').nth(2).fill(newSortNumber);
-      
-      await page.getByText('确定').click();
-      await page.waitForTimeout(1000);
+    // 步骤2：修改分组
+    await allure.step('修改分组', async () => {
+      await customerGroupPage.updateGroup(originalGroupName, newGroupName, newSortNumber);
     });
  
-    // 步骤3：验证分组修改成功 - 使用搜索验证修改后的内容
+    // 步骤3：验证分组修改成功
     await allure.step('验证分组修改成功', async () => {
-      // 在搜索框中输入新分组名称进行验证
-      await page.waitForTimeout(500);
-      await page.getByRole('textbox').click();
-      await page.getByRole('textbox').fill(newGroupName);
-      await page.waitForTimeout(500);
-      
-      const isNewGroupVisible = await page.locator('uni-view').filter({ hasText: new RegExp(`^${newGroupName}$`) }).first().isVisible({ timeout: 5000 }).catch(() => false);
-      expect(isNewGroupVisible).toBeTruthy();
+      const isExists = await customerGroupPage.verifyGroupExists(newGroupName);
+      expect(isExists).toBeTruthy();
     });
   });
  
   test('删除客户分组', async ({ page }, testInfo) => {
+    const customerGroupPage = new CustomerGroupPage(page);
+    
     // 添加allure元素
     await allure.epic('客户管理');
     await allure.feature('客户分组');
@@ -166,53 +115,20 @@ test.describe(&#39;客户分组&#39;, () =&gt; {
     const groupName = generateGroupName();
     console.log('待删除分组名称:', groupName);
  
-    // 步骤1：进入客户分组页面并创建分组
-    await allure.step('进入客户分组页面并创建分组', async () => {
-      await page.goto('/');
-      await page.waitForLoadState('networkidle', { timeout: 30000 });
-      await page.getByText('更多 >').click();
-      await page.waitForTimeout(500);
-      await page.getByText('客户分组').first().click();
-      await page.waitForLoadState('networkidle', { timeout: 30000 });
-      
-      // 创建分组
-      await page.getByText('新建').click();
-      await page.waitForTimeout(500);
-      await page.getByRole('textbox').nth(1).click();
-      await page.getByRole('textbox').nth(1).fill(groupName);
-      await page.getByText('确定').click();
-      await page.waitForTimeout(1000);
+    // 步骤1：先创建分组
+    await allure.step('创建待删除的分组', async () => {
+      await customerGroupPage.createGroup(groupName);
     });
  
-    // 步骤2：搜索并删除分组
-    await allure.step('搜索并删除分组', async () => {
-      // 在搜索框中输入分组名称
-      await page.getByRole('textbox').click();
-      await page.getByRole('textbox').fill(groupName);
-      
-      // 搜索后自动选中，直接点击删除按钮
-      await page.getByText('删除').click();
-      await page.waitForTimeout(500);
-      
-      // 确认删除
-      await page.getByText('确定', { exact: true }).click();
-      // await page.waitForTimeout(1000);
-      
-      // 点击清除按钮
-      await page.locator('.nut-searchbar__search-icon').click();
-      // 清除后等待页面刷新
-      await page.waitForTimeout(1000);
+    // 步骤2：删除分组
+    await allure.step('删除分组', async () => {
+      await customerGroupPage.deleteGroup(groupName);
     });
  
     // 步骤3：验证分组删除成功
     await allure.step('验证分组删除成功', async () => {
-      // 搜索已删除的分组名称
-      await page.getByRole('textbox').fill(groupName);
-      await page.waitForTimeout(1000);
-      
-      // 验证搜索结果中是否还能找到该分组（找不到才是删除成功）
-      const count = await page.locator('uni-view').filter({ hasText: new RegExp(`^${groupName}$`) }).count();
-      expect(count).toBe(0);
+      const isNotExists = await customerGroupPage.verifyGroupNotExists(groupName);
+      expect(isNotExists).toBeTruthy();
     });
   });
 });
+import { test, expect } from '@playwright/test';
+import * as allure from 'allure-js-commons';
+import { EmployeePage } from '../pages/employeePage';
+import { generateCustomerName, generatePhoneNumber } from '../utils/dataGenerator';
+
+/**
+ * 员工管理测试
+ */
+test.describe('员工管理', () => {
+  // 使用已保存的认证状态
+  test.use({ storageState: 'auth.json' });
+
+  // 强制测试串行执行
+  test.describe.configure({ mode: 'serial' });
+
+  /**
+   * 生成随机员工姓名（使用已有函数）
+   */
+  function generateEmployeeName(): string {
+    return generateCustomerName();
+  }
+
+  /**
+   * 生成随机联系电话（使用已有函数）
+   */
+  function generatePhone(): string {
+    return generatePhoneNumber();
+  }
+
+  /**
+   * 生成包含"自动化"的备注
+   */
+  function generateRemark(): string {
+    const timestamp = Date.now().toString().slice(-6);
+    return `自动化员工测试备注${timestamp}`;
+  }
+
+  test('新增员工', async ({ page }, testInfo) => {
+    const employeePage = new EmployeePage(page);
+    
+    // 添加allure元素
+    await allure.epic('员工管理');
+    await allure.feature('员工信息');
+    await allure.story('新增员工');
+
+    // 生成随机员工数据
+    const employeeName = generateEmployeeName();
+    const phone = generatePhone();
+    const remark = generateRemark();
+    
+    console.log('员工姓名:', employeeName);
+    console.log('联系电话:', phone);
+    console.log('备注:', remark);
+
+    // 步骤1：进入员工管理页面
+    await allure.step('进入员工管理页面', async () => {
+      await employeePage.openEmployeeManagement();
+    });
+
+    // 步骤2：点击新建员工按钮
+    await allure.step('点击新建员工按钮', async () => {
+      await employeePage.clickNewEmployee();
+    });
+
+    // 步骤3：点击手动添加
+    await allure.step('点击手动添加', async () => {
+      await employeePage.clickManualAdd();
+    });
+
+    // 步骤4：填写员工表单
+    await allure.step('填写员工表单', async () => {
+      await employeePage.fillEmployeeName(employeeName);
+      await employeePage.fillPhone(phone);
+      await employeePage.fillRemark(remark);
+      await employeePage.selectPosition(); // 不传参数，随机选择岗位
+    });
+
+    // 步骤5：保存员工
+    await allure.step('保存员工', async () => {
+      await employeePage.clickConfirm();
+    });
+
+    // 步骤6：验证员工创建成功
+    await allure.step('验证员工创建成功', async () => {
+      // 使用员工姓名搜索
+      await employeePage.searchEmployee(employeeName);
+      const isExists = await employeePage.verifyEmployeeExists(employeeName);
+      expect(isExists).toBeTruthy();
+    });
+  });
+
+  test('修改员工', async ({ page }, testInfo) => {
+    const employeePage = new EmployeePage(page);
+    
+    // 添加allure元素
+    await allure.epic('员工管理');
+    await allure.feature('员工信息');
+    await allure.story('修改员工');
+
+    // 先生成一个新员工用于修改测试
+    const employeeName = generateEmployeeName();
+    const phone = generatePhone();
+    const originalRemark = '新建员工备注';
+    
+    console.log('待修改员工姓名:', employeeName);
+    console.log('联系电话:', phone);
+
+    // 步骤1：新增员工
+    await allure.step('新增员工', async () => {
+      await employeePage.openEmployeeManagement();
+      await employeePage.clickNewEmployee();
+      await employeePage.clickManualAdd();
+      await employeePage.fillEmployeeName(employeeName);
+      await employeePage.fillPhone(phone);
+      await employeePage.fillRemark(originalRemark);
+      await employeePage.selectPosition();
+      await employeePage.clickConfirm();
+    });
+
+    // 步骤2：搜索员工
+    await allure.step('搜索员工', async () => {
+      await employeePage.searchEmployee(employeeName);
+      await employeePage.verifyEmployeeExists(employeeName);
+    });
+
+    // 步骤3：点击修改按钮
+    await allure.step('点击修改按钮', async () => {
+      await employeePage.clickEditButton();
+    });
+
+    // 步骤4：填写修改信息（姓名和电话不允许修改，只修改备注、状态、岗位）
+    await allure.step('填写修改信息', async () => {
+      const newRemark = '修改后的备注';
+      await employeePage.fillRemarkForEdit(newRemark);
+      await employeePage.clickStatusSwitch();
+      await employeePage.selectPositionForEdit('采购员');
+    });
+
+    // 步骤5：保存修改
+    await allure.step('保存修改', async () => {
+      await employeePage.clickConfirm();
+      await employeePage.page.waitForTimeout(1000);
+    });
+
+    // 步骤6：验证修改成功 - 搜索员工并检查备注是否包含"修改"
+    await allure.step('验证修改成功', async () => {
+      await employeePage.searchEmployee(employeeName);
+      const isSuccess = await employeePage.verifyEmployeeRemarkContains('修改');
+      expect(isSuccess).toBeTruthy();
+    });
+  });
+
+  test('解绑员工', async ({ page }, testInfo) => {
+    const employeePage = new EmployeePage(page);
+    
+    // 添加allure元素
+    await allure.epic('员工管理');
+    await allure.feature('员工信息');
+    await allure.story('解绑员工');
+
+    // 先生成一个新员工用于解绑测试
+    const employeeName = generateEmployeeName();
+    const phone = generatePhone();
+    const originalRemark = '解绑测试备注';
+    
+    console.log('待解绑员工姓名:', employeeName);
+    console.log('联系电话:', phone);
+
+    // 步骤1：新增员工
+    await allure.step('新增员工', async () => {
+      await employeePage.openEmployeeManagement();
+      await employeePage.clickNewEmployee();
+      await employeePage.clickManualAdd();
+      await employeePage.fillEmployeeName(employeeName);
+      await employeePage.fillPhone(phone);
+      await employeePage.fillRemark(originalRemark);
+      await employeePage.selectPosition();
+      await employeePage.clickConfirm();
+    });
+
+    // 步骤2：搜索员工
+    await allure.step('搜索员工', async () => {
+      await employeePage.searchEmployee(employeeName);
+      await employeePage.verifyEmployeeExists(employeeName);
+    });
+
+    // 步骤3：点击解绑按钮
+    await allure.step('点击解绑按钮', async () => {
+      await employeePage.clickUnbindButton();
+    });
+
+    // 步骤4：确认解绑
+    await allure.step('确认解绑', async () => {
+      await employeePage.confirmUnbind();
+    });
+
+    // 步骤5：验证解绑成功 - 页面不再显示该员工
+    await allure.step('验证解绑成功', async () => {
+      const isNotExists = await employeePage.verifyEmployeeNotExists(employeeName);
+      expect(isNotExists).toBeTruthy();
+    });
+  });
+});
 \ No newline at end of file
+import { test, expect } from '@playwright/test';
+import * as allure from 'allure-js-commons';
+import { ProductCategoryPage } from '../pages/productCategoryPage';
+
+/**
+ * 商品分类测试
+ */
+test.describe('商品分类', () => {
+  // 使用已保存的认证状态
+  test.use({ storageState: 'auth.json' });
+
+  // 强制测试串行执行，避免并行测试之间的干扰
+  test.describe.configure({ mode: 'serial' });
+
+  /**
+   * 生成随机分类名称
+   */
+  function generateCategoryName(): string {
+    const prefixes = ['畅销', '热卖', '新品', '精选', '推荐', '特惠', '优质', '普通'];
+    const timestamp = Date.now().toString().slice(-4);
+    return `${prefixes[Math.floor(Math.random() * prefixes.length)]}${timestamp}`;
+  }
+
+  test('新增商品分类', async ({ page }, testInfo) => {
+    const productCategoryPage = new ProductCategoryPage(page);
+    
+    // 添加allure元素
+    await allure.epic('商品管理');
+    await allure.feature('商品分类');
+    await allure.story('新增商品分类');
+
+    // 生成随机分类名称
+    const categoryName = generateCategoryName();
+    const categoryDescription = '畅销的商品';
+    console.log('新增分类名称:', categoryName);
+
+    // 步骤1：进入商品分类页面
+    await allure.step('进入商品分类页面', async () => {
+      await productCategoryPage.openProductCategoryManagement();
+    });
+
+    // 步骤2：点击新增分类按钮
+    await allure.step('点击新增分类按钮', async () => {
+      await productCategoryPage.clickAddCategory();
+    });
+
+    // 步骤3：输入分类名称
+    await allure.step('输入分类名称', async () => {
+      await productCategoryPage.enterCategoryName(categoryName);
+    });
+
+    // 步骤4：输入分类描述
+    await allure.step('输入分类描述', async () => {
+      await productCategoryPage.enterCategoryDescription(categoryDescription);
+    });
+
+    // 步骤5：状态默认启用，点击确定
+    await allure.step('点击确定按钮', async () => {
+      await productCategoryPage.clickConfirm();
+    });
+
+    // 步骤6：搜索新增的分类
+    await allure.step('搜索新增的分类', async () => {
+      await productCategoryPage.searchCategory(categoryName);
+    });
+
+    // 步骤7：验证分类创建成功
+    await allure.step('验证分类创建成功', async () => {
+      await productCategoryPage.expectCategoryVisible(categoryName);
+    });
+  });
+
+  test('修改商品分类', async ({ page }, testInfo) => {
+    const productCategoryPage = new ProductCategoryPage(page);
+    
+    // 添加allure元素
+    await allure.epic('商品管理');
+    await allure.feature('商品分类');
+    await allure.story('修改商品分类');
+
+    // 先生成一个分类用于修改
+    const originalCategoryName = generateCategoryName();
+    const modifiedCategoryName = `修改${originalCategoryName}`;
+    const originalDescription = '原始描述';
+    const modifiedDescription = '修改后的描述';
+    console.log('原分类名称:', originalCategoryName);
+    console.log('修改后分类名称:', modifiedCategoryName);
+
+    // 步骤1：先创建分类
+    await allure.step('创建待修改的分类', async () => {
+      await productCategoryPage.createCategory(originalCategoryName, originalDescription);
+    });
+
+    // 步骤2：搜索分类并点击修改
+    await allure.step('搜索并点击修改分类', async () => {
+      await productCategoryPage.searchCategory(originalCategoryName);
+      await productCategoryPage.clickEditCategory();
+    });
+
+    // 步骤3：修改分类名称
+    await allure.step('修改分类名称', async () => {
+      await productCategoryPage.enterCategoryName(modifiedCategoryName);
+    });
+
+    // 步骤4：修改分类描述
+    await allure.step('修改分类描述', async () => {
+      await productCategoryPage.enterCategoryDescription(modifiedDescription);
+    });
+
+    // 步骤5：切换状态（可选）
+    await allure.step('切换分类状态', async () => {
+      await productCategoryPage.toggleCategoryStatus();
+    });
+
+    // 步骤6：点击确定保存
+    await allure.step('保存修改', async () => {
+      await productCategoryPage.clickConfirm();
+    });
+
+    // 步骤7：清除搜索框并搜索修改后的分类
+    await allure.step('搜索修改后的分类', async () => {
+      await productCategoryPage.clearSearch();
+      await productCategoryPage.searchCategory(modifiedCategoryName);
+    });
+
+    // 步骤8：验证分类修改成功
+    await allure.step('验证分类修改成功', async () => {
+      await productCategoryPage.expectCategoryVisible(modifiedCategoryName);
+    });
+  });
+
+  test('删除商品分类', async ({ page }, testInfo) => {
+    const productCategoryPage = new ProductCategoryPage(page);
+    
+    // 添加allure元素
+    await allure.epic('商品管理');
+    await allure.feature('商品分类');
+    await allure.story('删除商品分类');
+
+    // 先生成一个分类用于删除
+    const categoryName = generateCategoryName();
+    console.log('删除分类名称:', categoryName);
+
+    // 步骤1：先创建分类
+    await allure.step('创建待删除的分类', async () => {
+      await productCategoryPage.createCategory(categoryName, '删除测试描述');
+    });
+
+    // 步骤2：搜索分类
+    await allure.step('搜索待删除的分类', async () => {
+      await productCategoryPage.searchCategory(categoryName);
+      await productCategoryPage.expectCategoryVisible(categoryName);
+    });
+
+    // 步骤3：点击删除分类
+    await allure.step('点击删除分类按钮', async () => {
+      await productCategoryPage.clickDeleteCategory();
+    });
+
+    // 步骤4：确认删除
+    await allure.step('确认删除', async () => {
+      await productCategoryPage.clickConfirm();
+    });
+
+    // 步骤5：验证分类已删除
+    await allure.step('验证分类已删除', async () => {
+      await productCategoryPage.expectCategoryNotVisible(categoryName);
+    });
+  });
+});
+import { test, expect } from '@playwright/test';
+import * as allure from 'allure-js-commons';
+import { PurchasePage } from '../pages/purchasePage';
+
+/**
+ * 采购入库测试
+ */
+test.describe('采购入库', () => {
+  // 使用已保存的认证状态
+  test.use({ storageState: 'auth.json' });
+
+  // 强制测试串行执行，避免并行测试之间的干扰
+  test.describe.configure({ mode: 'serial' });
+
+  test('采购入库存草稿', async ({ page }, testInfo) => {
+    const purchasePage = new PurchasePage(page);
+    
+    // 添加allure元素
+    await allure.epic('仓储管理');
+    await allure.feature('采购入库');
+    await allure.story('采购入库存草稿');
+
+    // 测试数据
+    let supplierName: string;
+    let warehouseName: string;
+    
+    let productName: string;
+
+    // 步骤1：进入采购入库页面
+    await allure.step('进入采购入库页面', async () => {
+      await purchasePage.openPurchaseInbound();
+    });
+
+    // 步骤2：随机选择商品
+    await allure.step('随机选择商品', async () => {
+      productName = await purchasePage.selectRandomProduct();
+      // console.log('商品:', productName);
+    });
+
+    // 步骤3：输入数量
+    await allure.step('输入数量', async () => {
+      await purchasePage.enterQuantity('1');
+    });
+
+    // 步骤5：输入单价
+    await allure.step('输入单价', async () => {
+      await purchasePage.enterPrice('2');
+    });
+
+    // 步骤6：点击完成
+    await allure.step('点击完成', async () => {
+      await purchasePage.clickDone();
+    });
+
+    // 步骤7：随机选择供应商
+    await allure.step('随机选择供应商', async () => {
+      supplierName = await purchasePage.getRandomSupplier();
+      // console.log('供应商:', supplierName);
+    });
+
+    // 步骤8：随机选择仓库
+    await allure.step('随机选择仓库', async () => {
+      warehouseName = await purchasePage.getRandomWarehouse();
+      // console.log('仓库:', warehouseName);
+    });
+
+    // 步骤9：存入草稿
+    await allure.step('存入草稿', async () => {
+      await purchasePage.clickSaveDraft();
+    });
+
+    // 步骤10：打开草稿单列表
+    await allure.step('打开草稿单列表', async () => {
+      await purchasePage.clickDraftList();
+    });
+
+    // 步骤11：搜索商品
+    await allure.step('搜索商品', async () => {
+      await purchasePage.searchInDraftList(productName!);
+    });
+
+    // 步骤12：验证草稿中存在该商品
+    await allure.step('验证草稿中存在该商品', async () => {
+      await purchasePage.expectDraftContainsProduct(productName!);
+    });
+  });
+
+  test('采购入库付款', async ({ page }, testInfo) => {
+    const purchasePage = new PurchasePage(page);
+    
+    // 添加allure元素
+    await allure.epic('仓储管理');
+    await allure.feature('采购入库');
+    await allure.story('采购入库付款');
+    
+    // 测试数据
+    let supplierName: string;
+    let warehouseName: string;
+    let productName: string;
+    
+    // 步骤1：进入采购入库页面
+    await allure.step('进入采购入库页面', async () => {
+      await purchasePage.openPurchaseInbound();
+    });
+    
+    // 步骤2：随机选择商品
+    await allure.step('随机选择商品', async () => {
+      productName = await purchasePage.selectRandomProduct();
+      // console.log('商品:', productName);
+    });
+    
+    // 步骤3：输入数量
+    await allure.step('输入数量', async () => {
+      await purchasePage.enterQuantity('1');
+    });
+    
+    // 步骤4：输入单价
+    await allure.step('输入单价', async () => {
+      await purchasePage.enterPrice('1');
+    });
+    
+    // 步骤5：点击完成
+    await allure.step('点击完成', async () => {
+      await purchasePage.clickDone();
+    });
+    
+    // 步骤6：添加入库费用
+    await allure.step('添加入库费用', async () => {
+      await purchasePage.addExpense(0, '1');
+    });
+    
+    // 步骤7：随机选择供应商
+    await allure.step('随机选择供应商', async () => {
+      supplierName = await purchasePage.getRandomSupplier();
+      // console.log('供应商:', supplierName);
+    });
+    
+    // 步骤8：随机选择仓库
+    await allure.step('随机选择仓库', async () => {
+      warehouseName = await purchasePage.getRandomWarehouse();
+      // console.log('仓库:', warehouseName);
+    });
+    
+    // 步骤9：选择采购员
+    await allure.step('选择采购员', async () => {
+      await purchasePage.selectPurchaser();
+    });
+    
+    // 步骤10：输入车牌号
+    await allure.step('输入车牌号', async () => {
+      await purchasePage.enterLicensePlate('渝YUNI99');
+    });
+    
+    // 步骤11：输入备注
+    await allure.step('输入备注', async () => {
+      await purchasePage.enterRemark('自动化测试');
+    });
+    
+    // 步骤12：上传图片（暂时跳过）
+    // await allure.step('上传图片', async () => {
+    //   await purchasePage.uploadImage('test-data/img/苹果.jpg');
+    // });
+    
+    // 步骤13：点击付款
+    await allure.step('点击付款', async () => {
+      await purchasePage.clickPay();
+    });
+    
+    // 步骤14：选择结算账户
+    await allure.step('选择结算账户', async () => {
+      await purchasePage.selectSettlementAccount('微信支付');
+    });
+    
+    // 步骤15：确认付款
+    await allure.step('确认付款', async () => {
+      await purchasePage.confirmPayment();
+    });
+    
+    // 步骤16：进入采购列表
+    await allure.step('进入采购列表', async () => {
+      await purchasePage.goToPurchaseList();
+    });
+    
+    // 步骤17：搜索商品
+    await allure.step('搜索商品', async () => {
+      await purchasePage.searchInPurchaseList(productName);
+    });
+    
+    // 步骤18：验证采购列表中存在该商品
+    await allure.step('验证采购列表中存在该商品', async () => {
+      await purchasePage.expectPurchaseListContainsProduct(productName);
+    });
+  });
+
+  test('采购入库草稿编辑', async ({ page }, testInfo) => {
+    const purchasePage = new PurchasePage(page);
+
+    // 添加allure元素
+    await allure.epic('仓储管理');
+    await allure.feature('采购入库');
+    await allure.story('采购入库草稿编辑');
+
+    // 测试数据
+    let supplierName: string;
+    let warehouseName: string;
+    let productName: string;
+
+    // 步骤1：进入采购入库页面
+    await allure.step('进入采购入库页面', async () => {
+      await purchasePage.openPurchaseInbound();
+    });
+
+    // 步骤2：随机选择商品
+    await allure.step('随机选择商品', async () => {
+      productName = await purchasePage.selectRandomProduct();
+      // console.log('商品:', productName);
+    });
+
+    // 步骤3：输入数量
+    await allure.step('输入数量', async () => {
+      await purchasePage.enterQuantity('1');
+    });
+
+    // 步骤4：输入单价
+    await allure.step('输入单价', async () => {
+      await purchasePage.enterPrice('1');
+    });
+
+    // 步骤5：点击完成
+    await allure.step('点击完成', async () => {
+      await purchasePage.clickDone();
+    });
+
+    // 步骤6：随机选择供应商
+    await allure.step('随机选择供应商', async () => {
+      supplierName = await purchasePage.getRandomSupplier();
+      // console.log('供应商:', supplierName);
+    });
+
+    // 步骤7：随机选择仓库
+    await allure.step('随机选择仓库', async () => {
+      warehouseName = await purchasePage.getRandomWarehouse();
+      // console.log('仓库:', warehouseName);
+    });
+
+    // 步骤8：存入草稿
+    await allure.step('存入草稿', async () => {
+      await purchasePage.clickSaveDraft();
+      await page.waitForTimeout(1000);
+    });
+
+    // 步骤9：打开草稿单列表
+    await allure.step('打开草稿单列表', async () => {
+      await purchasePage.clickDraftList();
+    });
+
+    // 步骤10：搜索商品
+    await allure.step('搜索商品', async () => {
+      await purchasePage.searchInDraftList(productName);
+    });
+
+    // 步骤11：点击草稿单商品进入编辑页
+    await allure.step('点击草稿单商品进入编辑页', async () => {
+      await purchasePage.clickDraftProduct();
+    });
+
+    // 步骤12：选择采购员
+    await allure.step('选择采购员', async () => {
+      await purchasePage.selectPurchaser();
+    });
+
+    // 步骤13：添加入库费用
+    await allure.step('添加入库费用', async () => {
+      await purchasePage.addExpense(0, '1');
+    });
+
+    // 步骤14：点击付款
+    await allure.step('点击付款', async () => {
+      await purchasePage.clickPay();
+    });
+
+    // 步骤15：选择结算账户
+    await allure.step('选择结算账户', async () => {
+      await purchasePage.selectSettlementAccount('微信支付');
+    });
+
+    // 步骤16：确认付款
+    await allure.step('确认付款', async () => {
+      await purchasePage.confirmPayment();
+    });
+
+    // 步骤17：进入采购列表
+    await allure.step('进入采购列表', async () => {
+      await purchasePage.goToPurchaseList();
+    });
+
+    // 步骤18：搜索商品
+    await allure.step('搜索商品', async () => {
+      await purchasePage.searchInPurchaseList(productName);
+    });
+
+    // 步骤19：验证采购列表中存在该商品
+    await allure.step('验证采购列表中存在该商品', async () => {
+      await purchasePage.expectPurchaseListContainsProduct(productName);
+    });
+  });
+
+  test('采购入库保存后付款', async ({ page }, testInfo) => {
+    const purchasePage = new PurchasePage(page);
+
+    // 添加allure元素
+    await allure.epic('仓储管理');
+    await allure.feature('采购入库');
+    await allure.story('采购入库保存后付款');
+
+    // 测试数据
+    let supplierName: string;
+    let warehouseName: string;
+    let productName: string;
+
+    // 步骤1：进入采购入库页面
+    await allure.step('进入采购入库页面', async () => {
+      await purchasePage.openPurchaseInbound();
+    });
+
+    // 步骤2：随机选择商品
+    await allure.step('随机选择商品', async () => {
+      productName = await purchasePage.selectRandomProduct();
+      console.log('商品:', productName);
+    });
+
+    // 步骤3：输入数量
+    await allure.step('输入数量', async () => {
+      await purchasePage.enterQuantity('1');
+    });
+
+    // 步骤4：输入单价
+    await allure.step('输入单价', async () => {
+      await purchasePage.enterPrice('1');
+    });
+
+    // 步骤5：点击完成
+    await allure.step('点击完成', async () => {
+      await purchasePage.clickDone();
+    });
+
+    // 步骤6：添加入库费用
+    await allure.step('添加入库费用', async () => {
+      await purchasePage.addExpense(0, '1');
+    });
+
+    // 步骤7：随机选择供应商
+    await allure.step('随机选择供应商', async () => {
+      supplierName = await purchasePage.getRandomSupplier();
+      console.log('供应商:', supplierName);
+    });
+
+    // 步骤8：随机选择仓库
+    await allure.step('随机选择仓库', async () => {
+      warehouseName = await purchasePage.getRandomWarehouse();
+      console.log('仓库:', warehouseName);
+    });
+
+    // 步骤9：选择采购员
+    await allure.step('选择采购员', async () => {
+      await purchasePage.selectPurchaser();
+    });
+
+    // 步骤10：输入车牌号
+    await allure.step('输入车牌号', async () => {
+      await purchasePage.enterLicensePlate('渝YUNI99');
+    });
+
+    // 步骤11：输入备注
+    await allure.step('输入备注', async () => {
+      await purchasePage.enterRemark('自动化测试');
+    });
+
+    // 步骤12：点击保存
+    await allure.step('点击保存', async () => {
+      await purchasePage.clickSave();
+    });
+
+    // 步骤13：搜索商品
+    await allure.step('搜索商品', async () => {
+      await purchasePage.searchInPurchaseList(productName);
+    });
+
+    // 步骤14：验证采购单状态为待支付
+    await allure.step('验证采购单状态为待支付', async () => {
+      await purchasePage.expectPurchaseOrderStatusPending(productName);
+    });
+
+    // 步骤15：点击付款
+    await allure.step('点击付款', async () => {
+      await purchasePage.clickPay(1);
+    });
+
+    // 步骤16：选择结算账户（支付成功，无确认弹窗）
+    await allure.step('选择结算账户', async () => {
+      await purchasePage.selectSettlementAccount('微信支付');
+    });
+
+    // 步骤17：搜索商品
+    await allure.step('搜索商品', async () => {
+      await purchasePage.searchInPurchaseList(productName);
+    });
+
+    // 步骤18：验证采购单状态为已支付
+    await allure.step('验证采购单状态为已支付', async () => {
+      await purchasePage.expectPurchaseOrderStatusPaid();
+    });
+  });
+
+  test('采购单复制创建付款', async ({ page }, testInfo) => {
+    const purchasePage = new PurchasePage(page);
+
+    // 添加allure元素
+    await allure.epic('仓储管理');
+    await allure.feature('采购入库');
+    await allure.story('采购单复制创建付款');
+
+    // 测试数据
+    let supplierName: string;
+    let warehouseName: string;
+    let productName: string;
+
+    // 步骤1：进入采购入库页面
+    await allure.step('进入采购入库页面', async () => {
+      await purchasePage.openPurchaseInbound();
+    });
+
+    // 步骤2：随机选择商品
+    await allure.step('随机选择商品', async () => {
+      productName = await purchasePage.selectRandomProduct();
+      console.log('商品:', productName);
+    });
+
+    // 步骤3：输入数量
+    await allure.step('输入数量', async () => {
+      await purchasePage.enterQuantity('1');
+    });
+
+    // 步骤4：输入单价
+    await allure.step('输入单价', async () => {
+      await purchasePage.enterPrice('1');
+    });
+
+    // 步骤5：点击完成
+    await allure.step('点击完成', async () => {
+      await purchasePage.clickDone();
+    });
+
+    // 步骤6：随机选择供应商
+    await allure.step('随机选择供应商', async () => {
+      supplierName = await purchasePage.getRandomSupplier();
+      console.log('供应商:', supplierName);
+    });
+
+    // 步骤7：随机选择仓库
+    await allure.step('随机选择仓库', async () => {
+      warehouseName = await purchasePage.getRandomWarehouse();
+      console.log('仓库:', warehouseName);
+    });
+
+    // 步骤8：点击保存
+    await allure.step('点击保存', async () => {
+      await purchasePage.clickSave();
+    });
+
+    // 步骤9：搜索商品
+    await allure.step('搜索商品', async () => {
+      await purchasePage.searchInPurchaseList(productName);
+    });
+
+    // 步骤10：点击复制创建
+    await allure.step('点击复制创建', async () => {
+      await purchasePage.clickCopyCreate();
+    });
+
+    // 步骤11：点击货款小计并输入
+    await allure.step('点击货款小计并输入金额', async () => {
+      await purchasePage.clickSubtotal();
+      await purchasePage.enterSubtotalAmount('1');
+    });
+
+    // 步骤12：添加入库费用
+    await allure.step('添加入库费用', async () => {
+      await purchasePage.addExpense(0, '1');
+    });
+
+    // 步骤13：输入存储温度
+    await allure.step('输入存储温度', async () => {
+      await purchasePage.enterStorageTemperature('6');
+    });
+
+    // 步骤14：选择采购员
+    await allure.step('选择采购员', async () => {
+      await purchasePage.selectPurchaser();
+    });
+
+    // 步骤15：输入车牌号
+    await allure.step('输入车牌号', async () => {
+      await purchasePage.enterLicensePlate('渝YUNI99');
+    });
+
+    // 步骤16：输入备注
+    await allure.step('输入备注', async () => {
+      await purchasePage.enterRemark('1111111');
+    });
+
+    // 步骤17：点击付款
+    await allure.step('点击付款', async () => {
+      await purchasePage.clickPay();
+    });
+
+    // 步骤18：选择结算账户
+    await allure.step('选择结算账户', async () => {
+      await purchasePage.selectSettlementAccount('微信支付');
+    });
+
+    // 步骤19：确认付款
+    await allure.step('确认付款', async () => {
+      await purchasePage.confirmPayment();
+    });
+
+    // 步骤20：清除搜索结果并重新搜索
+    await allure.step('清除搜索结果并重新搜索', async () => {
+      await purchasePage.clearSearchInPurchaseList();
+      await purchasePage.searchInPurchaseList(productName);
+    });
+
+    // 步骤21：验证采购单状态为已支付
+    await allure.step('验证采购单状态为已支付', async () => {
+      await purchasePage.expectPurchaseOrderStatusPaid();
+    });
+  });
+
+  test('采购单编辑保存', async ({ page }, testInfo) => {
+    test.setTimeout(60000);
+    const purchasePage = new PurchasePage(page);
+
+    // 添加allure元素
+    await allure.epic('仓储管理');
+    await allure.feature('采购入库');
+    await allure.story('采购单编辑保存');
+
+    // 测试数据
+    let supplierName: string;
+    let warehouseName: string;
+    let productName: string;
+    let newSupplierName: string;
+    let newWarehouseName: string;
+
+    // 步骤1：进入采购入库页面
+    await allure.step('进入采购入库页面', async () => {
+      await purchasePage.openPurchaseInbound();
+    });
+
+    // 步骤2：随机选择商品
+    await allure.step('随机选择商品', async () => {
+      productName = await purchasePage.selectRandomProduct();
+      console.log('商品:', productName);
+    });
+
+    // 步骤3：输入数量
+    await allure.step('输入数量', async () => {
+      await purchasePage.enterQuantity('1');
+    });
+
+    // 步骤4：输入单价
+    await allure.step('输入单价', async () => {
+      await purchasePage.enterPrice('1');
+    });
+
+    // 步骤5：点击完成
+    await allure.step('点击完成', async () => {
+      await purchasePage.clickDone();
+    });
+
+    // 步骤6：随机选择供应商
+    await allure.step('随机选择供应商', async () => {
+      supplierName = await purchasePage.getRandomSupplier();
+      console.log('供应商:', supplierName);
+    });
+
+    // 步骤7：随机选择仓库
+    await allure.step('随机选择仓库', async () => {
+      warehouseName = await purchasePage.getRandomWarehouse();
+      console.log('仓库:', warehouseName);
+    });
+
+    // 步骤8：点击保存
+    await allure.step('点击保存', async () => {
+      await purchasePage.clickSave();
+    });
+
+    // 步骤9：搜索商品
+    await allure.step('搜索商品', async () => {
+      await purchasePage.searchInPurchaseList(productName);
+    });
+
+    // 步骤10：点击修改按钮进入编辑页
+    await allure.step('点击修改按钮', async () => {
+      await purchasePage.clickEditButton();
+    });
+
+    // 步骤11：连续添加两个商品
+    await allure.step('添加第一个商品', async () => {
+      const name = await purchasePage.selectRandomProduct();
+      console.log('添加商品1:', name);
+      await purchasePage.enterQuantity('1');
+      await purchasePage.enterPrice('1');
+      await purchasePage.clickDone();
+    });
+
+    await allure.step('添加第二个商品', async () => {
+      const name = await purchasePage.selectRandomProduct();
+      console.log('添加商品2:', name);
+      await purchasePage.enterQuantity('1');
+      await purchasePage.enterPrice('1');
+      await purchasePage.clickDone();
+    });
+
+    // 步骤12：填写货款优惠
+    await allure.step('填写货款优惠', async () => {
+      await purchasePage.clickSubtotal();
+      await purchasePage.enterSubtotalAmount('1');
+    });
+
+    // 步骤13：添加入库费用
+    await allure.step('添加入库费用', async () => {
+      await purchasePage.addExpense(0, '1');
+    });
+
+    // 步骤14：换选供应商
+    await allure.step('换选供应商', async () => {
+      newSupplierName = await purchasePage.getRandomSupplier();
+      console.log('新供应商:', newSupplierName);
+    });
+
+    // 步骤15：换选仓库
+    await allure.step('换选仓库', async () => {
+      newWarehouseName = await purchasePage.getRandomWarehouse();
+      console.log('新仓库:', newWarehouseName);
+    });
+
+    // 步骤16：选择入账日期
+    await allure.step('选择入账日期', async () => {
+      await purchasePage.selectEntryDate();
+    });
+
+    // 步骤17：清除并输入批次别名
+    await allure.step('输入批次别名', async () => {
+      await purchasePage.clearAndEnterBatchAlias('批次003');
+    });
+
+    // 步骤18：点击保存
+    await allure.step('点击保存', async () => {
+      await purchasePage.clickSave();
+    });
+
+    // 步骤19：按供应商搜索
+    await allure.step('按供应商搜索', async () => {
+      await purchasePage.searchInPurchaseList(newSupplierName);
+    });
+
+    // 步骤20：验证采购列表中存在该商品
+    await allure.step('验证采购列表中存在该商品', async () => {
+      await purchasePage.expectPurchaseListContainsProduct(productName);
+    });
+  });
+
+  test('采购单取消', async ({ page }, testInfo) => {
+    const purchasePage = new PurchasePage(page);
+
+    // 添加allure元素
+    await allure.epic('仓储管理');
+    await allure.feature('采购入库');
+    await allure.story('采购单取消');
+
+    // 测试数据
+    let supplierName: string;
+    let warehouseName: string;
+    let productName: string;
+
+    // 步骤1：进入采购入库页面
+    await allure.step('进入采购入库页面', async () => {
+      await purchasePage.openPurchaseInbound();
+    });
+
+    // 步骤2：随机选择商品
+    await allure.step('随机选择商品', async () => {
+      productName = await purchasePage.selectRandomProduct();
+      console.log('商品:', productName);
+    });
+
+    // 步骤3：输入数量
+    await allure.step('输入数量', async () => {
+      await purchasePage.enterQuantity('1');
+    });
+
+    // 步骤4：输入单价
+    await allure.step('输入单价', async () => {
+      await purchasePage.enterPrice('1');
+    });
+
+    // 步骤5：点击完成
+    await allure.step('点击完成', async () => {
+      await purchasePage.clickDone();
+    });
+
+    // 步骤6：随机选择供应商
+    await allure.step('随机选择供应商', async () => {
+      supplierName = await purchasePage.getRandomSupplier();
+      console.log('供应商:', supplierName);
+    });
+
+    // 步骤7：随机选择仓库
+    await allure.step('随机选择仓库', async () => {
+      warehouseName = await purchasePage.getRandomWarehouse();
+      console.log('仓库:', warehouseName);
+    });
+
+    // 步骤8：点击保存
+    await allure.step('点击保存', async () => {
+      await purchasePage.clickSave();
+    });
+
+    // 步骤9：搜索商品
+    await allure.step('搜索商品', async () => {
+      await purchasePage.searchInPurchaseList(productName);
+    });
+
+    // 步骤10：点击取消按钮
+    await allure.step('点击取消按钮', async () => {
+      await purchasePage.clickCancelButton();
+    });
+
+    // 步骤11：确认取消弹窗
+    await allure.step('确认取消弹窗', async () => {
+      await purchasePage.confirmCancelDialog();
+    });
+
+    // 步骤12：清除搜索框并重新搜索商品
+    await allure.step('清除搜索并重新搜索', async () => {
+      await purchasePage.clearSearchInPurchaseList();
+      await purchasePage.searchInPurchaseList(productName);
+    });
+
+    // 步骤13：验证采购单状态为已取消
+    await allure.step('验证采购单状态为已取消', async () => {
+      await purchasePage.expectPurchaseOrderStatusCancelled();
+    });
+  });
+
+  test('采购单撤销', async ({ page }, testInfo) => {
+    const purchasePage = new PurchasePage(page);
+
+    // 添加allure元素
+    await allure.epic('仓储管理');
+    await allure.feature('采购入库');
+    await allure.story('采购单撤销');
+
+    // 测试数据
+    let supplierName: string;
+    let warehouseName: string;
+    let productName: string;
+
+    // 步骤1：进入采购入库页面
+    await allure.step('进入采购入库页面', async () => {
+      await purchasePage.openPurchaseInbound();
+    });
+
+    // 步骤2：随机选择商品
+    await allure.step('随机选择商品', async () => {
+      productName = await purchasePage.selectRandomProduct();
+      console.log('商品:', productName);
+    });
+
+    // 步骤3：输入数量
+    await allure.step('输入数量', async () => {
+      await purchasePage.enterQuantity('1');
+    });
+
+    // 步骤4：输入单价
+    await allure.step('输入单价', async () => {
+      await purchasePage.enterPrice('1');
+    });
+
+    // 步骤5：点击完成
+    await allure.step('点击完成', async () => {
+      await purchasePage.clickDone();
+    });
+
+    // 步骤6：添加入库费用
+    await allure.step('添加入库费用', async () => {
+      await purchasePage.addExpense(0, '1');
+    });
+
+    // 步骤7：随机选择供应商
+    await allure.step('随机选择供应商', async () => {
+      supplierName = await purchasePage.getRandomSupplier();
+      console.log('供应商:', supplierName);
+    });
+
+    // 步骤8：随机选择仓库
+    await allure.step('随机选择仓库', async () => {
+      warehouseName = await purchasePage.getRandomWarehouse();
+      console.log('仓库:', warehouseName);
+    });
+
+    // 步骤9：选择采购员
+    await allure.step('选择采购员', async () => {
+      await purchasePage.selectPurchaser();
+    });
+
+    // 步骤10：输入车牌号
+    await allure.step('输入车牌号', async () => {
+      await purchasePage.enterLicensePlate('渝YUNI99');
+    });
+
+    // 步骤11：输入备注
+    await allure.step('输入备注', async () => {
+      await purchasePage.enterRemark('自动化测试');
+    });
+
+    // 步骤12：点击付款
+    await allure.step('点击付款', async () => {
+      await purchasePage.clickPay();
+    });
+
+    // 步骤13：选择结算账户
+    await allure.step('选择结算账户', async () => {
+      await purchasePage.selectSettlementAccount('微信支付');
+    });
+
+    // 步骤14：确认付款
+    await allure.step('确认付款', async () => {
+      await purchasePage.confirmPayment();
+    });
+
+    // 步骤15：进入采购列表
+    await allure.step('进入采购列表', async () => {
+      await purchasePage.goToPurchaseList();
+    });
+
+    // 步骤16：搜索商品
+    await allure.step('搜索商品', async () => {
+      await purchasePage.searchInPurchaseList(productName);
+    });
+
+    // 步骤17：点击撤销按钮
+    await allure.step('点击撤销按钮', async () => {
+      await purchasePage.clickRevokeButton();
+    });
+
+    // 步骤18：确认撤销弹窗
+    await allure.step('确认撤销弹窗', async () => {
+      await purchasePage.confirmCancelDialog();
+    });
+
+    // 步骤19：清除搜索并重新搜索商品
+    await allure.step('清除搜索并重新搜索', async () => {
+      await purchasePage.clearSearchInPurchaseList();
+      await purchasePage.searchInPurchaseList(productName);
+    });
+
+    // 步骤20：验证采购单状态为已撤销
+    await allure.step('验证采购单状态为已撤销', async () => {
+      await purchasePage.expectPurchaseOrderStatusRevoked();
+    });
+  });
+});
 \ No newline at end of file