mini-starter/web/tests/e2e/specs/admin/disability-person-card-number.spec.ts

import { TIMEOUTS } from '../../utils/timeouts';
import { test, expect } from '../../utils/test-setup';
import { readFileSync } from 'fs';
import { join, dirname } from 'path';
import { fileURLToPath } from 'url';

const __filename = fileURLToPath(import.meta.url);
const __dirname = dirname(__filename);
const testUsers = JSON.parse(readFileSync(join(__dirname, '../../fixtures/test-users.json'), 'utf-8'));

/**
 * Story 15.1: 残疾证号自动填充残疾类别和等级
 *
 * 验收标准:
 * 1. 输入有效残疾证号（20位：18位身份证 + 2位编码），系统自动解析并填充残疾类别和等级
 * 2. 残疾类别编码：1=视力残疾、2=听力残疾、3=言语残疾、4=肢体残疾、5=智力残疾、6=精神残疾、7=多重残疾
 * 3. 残疾等级编码：1=一级（最重）、2=二级、3=三级、4=四级（最轻）
 * 4. 边界条件：长度不足、编码超出范围时，不进行自动填充
 * 5. 用户可以手动修改自动填充的值
 */

test.describe('残疾证号自动填充功能测试', () => {
  // 测试数据：残疾证号格式 [18位身份证][残疾类别编码][残疾等级编码]
  const testCases = {
    // 有效残疾证号（20位）
    valid: {
      visionLevel1: {
        disabilityId: '11010119900101123411', // 视力残疾 + 一级
        expectedType: '视力残疾',
        expectedLevel: '一级'
      },
      hearingLevel2: {
        disabilityId: '11010119900101123422', // 听力残疾 + 二级
        expectedType: '听力残疾',
        expectedLevel: '二级'
      },
      speechLevel3: {
        disabilityId: '11010119900101123433', // 言语残疾 + 三级
        expectedType: '言语残疾',
        expectedLevel: '三级'
      },
      physicalLevel4: {
        disabilityId: '11010119900101123444', // 肢体残疾 + 四级
        expectedType: '肢体残疾',
        expectedLevel: '四级'
      },
      mentalLevel1: {
        disabilityId: '11010119900101123451', // 智力残疾 + 一级
        expectedType: '智力残疾',
        expectedLevel: '一级'
      },
      psychiatricLevel2: {
        disabilityId: '11010119900101123462', // 精神残疾 + 二级
        expectedType: '精神残疾',
        expectedLevel: '二级'
      },
      multipleLevel3: {
        disabilityId: '11010119900101123473', // 多重残疾 + 三级
        expectedType: '多重残疾',
        expectedLevel: '三级'
      }
    },
    // 无效残疾证号
    invalid: {
      tooShort: {
        disabilityId: '1101011990010112341', // 19位，长度不足
        description: '长度不足20位'
      },
      tooLong: {
        disabilityId: '110101199001011234111', // 21位，长度超出
        description: '长度超过20位'
      },
      invalidTypeCode: {
        disabilityId: '11010119900101123481', // 类别编码8（无效范围1-7）
        description: '残疾类别编码超出范围'
      },
      invalidLevelCode: {
        disabilityId: '11010119900101123415', // 等级编码5（无效范围1-4）
        description: '残疾等级编码超出范围'
      },
      bothInvalid: {
        disabilityId: '11010119900101123489', // 类别编码8，等级编码9（都无效）
        description: '两个编码都无效'
      }
    }
  };

  const generateTestPerson = () => ({
    name: `测试用户_${Date.now()}`,
    gender: '男',
    idCard: '420101199001011234',
    phone: '13800138000',
    idAddress: '湖北省武汉市测试街道123号',
    province: '湖北省',
    city: '武汉市'
  });

  test.beforeEach(async ({ adminLoginPage, disabilityPersonPage }) => {
    await adminLoginPage.goto();
    await adminLoginPage.login(testUsers.admin.username, testUsers.admin.password);
    await adminLoginPage.expectLoginSuccess();
    await disabilityPersonPage.goto();
  });

  test.afterEach(async ({ disabilityPersonPage, page }) => {
    // 清理测试数据
    try {
      await disabilityPersonPage.goto();
      const searchInput = page.getByPlaceholder('搜索姓名或身份证号');
      if (await searchInput.count() > 0) {
        await searchInput.fill(`测试用户_${Date.now()}`);
        await page.waitForTimeout(TIMEOUTS.VERY_SHORT);
        // 如果有搜索结果，可以清理（此处简化处理）
      }
    } catch (error) {
      console.debug('清理测试数据时出错:', error);
    }
  });

  test.describe('AC1: 输入有效残疾证号，验证自动填充', () => {
    test('应该自动解析并填充残疾类别和等级 - 视力残疾一级', async ({ disabilityPersonPage, page }) => {
      const testData = generateTestPerson();
      const testCase = testCases.valid.visionLevel1;

      console.debug('\n========== 测试：视力残疾一级自动填充 ==========');

      // 1. 打开新增对话框
      await disabilityPersonPage.openCreateDialog();
      console.debug('✓ 对话框已打开');

      // 2. 填写基本信息（不包括残疾证号）
      const form = page.locator('form#create-form');
      await form.waitFor({ state: 'visible', timeout: TIMEOUTS.DIALOG });

      await form.getByLabel('姓名 *').fill(testData.name);
      // 性别 - 使用 Radix UI Select 方式
      const genderTrigger = page.locator('[data-testid="gender-select"]');
      await genderTrigger.click();
      await page.getByRole('option', { name: testData.gender }).click();
      await form.getByLabel('身份证号 *').fill(testData.idCard);
      console.debug('✓ 基本信息（姓名、性别、身份证号）已填写');

      // 3. 记录初始下拉框值
      const disabilityTypeTrigger = page.locator('[data-testid="disability-type-select"]');
      const disabilityLevelTrigger = page.locator('[data-testid="disability-level-select"]');

      const initialTypeValue = await disabilityTypeTrigger.innerText();
      const initialLevelValue = await disabilityLevelTrigger.innerText();
      console.debug('✓ 初始残疾类别:', initialTypeValue);
      console.debug('✓ 初始残疾等级:', initialLevelValue);

      // 4. 输入残疾证号（20位数字编码）
      const disabilityIdInput = form.getByLabel('残疾证号 *');
      await disabilityIdInput.fill(testCase.disabilityId);
      console.debug('✓ 残疾证号已输入:', testCase.disabilityId);

      // 5. 等待自动填充生效
      await page.waitForTimeout(TIMEOUTS.VERY_SHORT);

      // 6. 验证残疾类别下拉框自动选中
      // Radix UI Select 在 trigger 的 generic 元素中显示选中值
      const selectedTypeText = await disabilityTypeTrigger.textContent();
      expect(selectedTypeText).toContain(testCase.expectedType);
      console.debug('✓ 残疾类别已自动填充:', testCase.expectedType);

      // 7. 验证残疾等级下拉框自动选中
      const selectedLevelText = await disabilityLevelTrigger.textContent();
      expect(selectedLevelText).toContain(testCase.expectedLevel);
      console.debug('✓ 残疾等级已自动填充:', testCase.expectedLevel);

      console.debug('✅ 测试通过：视力残疾一级自动填充正确');
    });

    test('应该自动解析并填充残疾类别和等级 - 所有类别组合测试', async ({ disabilityPersonPage, page }) => {
      const testData = generateTestPerson();

      // 测试所有7种残疾类别 × 4种等级的组合
      const allValidCases = [
        testCases.valid.visionLevel1,
        testCases.valid.hearingLevel2,
        testCases.valid.speechLevel3,
        testCases.valid.physicalLevel4,
        testCases.valid.mentalLevel1,
        testCases.valid.psychiatricLevel2,
        testCases.valid.multipleLevel3
      ];

      for (let i = 0; i < allValidCases.length; i++) {
        const testCase = allValidCases[i];
        console.debug(`\n========== 测试组合 ${i + 1}/${allValidCases.length}: ${testCase.expectedType} + ${testCase.expectedLevel} ==========`);

        // 打开新增对话框
        await disabilityPersonPage.openCreateDialog();

        const form = page.locator('form#create-form');
        await form.waitFor({ state: 'visible', timeout: TIMEOUTS.DIALOG });

        await form.getByLabel('姓名 *').fill(`${testData.name}_${i}`);
        // 性别 - 使用 Radix UI Select 方式
        const genderTrigger = page.locator('[data-testid="gender-select"]');
        await genderTrigger.click();
        await page.getByRole('option', { name: testData.gender }).click();
        await form.getByLabel('身份证号 *').fill(`${testData.idCard}${i}`);

        // 输入残疾证号
        const disabilityIdInput = form.getByLabel('残疾证号 *');
        await disabilityIdInput.fill(testCase.disabilityId);
        await page.waitForTimeout(TIMEOUTS.VERY_SHORT);

        // 验证残疾类别
        const disabilityTypeTrigger = page.locator('[data-testid="disability-type-select"]');
        const selectedTypeText = await disabilityTypeTrigger.textContent();
        expect(selectedTypeText).toContain(testCase.expectedType);

        // 验证残疾等级
        const disabilityLevelTrigger = page.locator('[data-testid="disability-level-select"]');
        const selectedLevelText = await disabilityLevelTrigger.textContent();
        expect(selectedLevelText).toContain(testCase.expectedLevel);

        console.debug(`✓ ${testCase.expectedType} + ${testCase.expectedLevel} 验证通过`);

        // 关闭对话框
        await page.locator('button').filter({ hasText: '取消' }).click();
        await page.waitForTimeout(TIMEOUTS.VERY_SHORT);
      }

      console.debug('✅ 所有残疾类别和等级组合测试通过');
    });
  });

  test.describe('AC4: 边界条件处理', () => {
    test('长度不足20位的残疾证号，不应触发自动填充', async ({ disabilityPersonPage, page }) => {
      const testData = generateTestPerson();
      const testCase = testCases.invalid.tooShort;

      console.debug('\n========== 测试：长度不足20位不自动填充 ==========');

      await disabilityPersonPage.openCreateDialog();

      const form = page.locator('form#create-form');
      await form.waitFor({ state: 'visible', timeout: TIMEOUTS.DIALOG });

      await form.getByLabel('姓名 *').fill(testData.name);
      // 性别 - 使用 Radix UI Select 方式
      const genderTrigger = page.locator('[data-testid="gender-select"]');
      await genderTrigger.click();
      await page.getByRole('option', { name: testData.gender }).click();
      await form.getByLabel('身份证号 *').fill(testData.idCard);

      // 输入长度不足的残疾证号
      const disabilityIdInput = form.getByLabel('残疾证号 *');
      await disabilityIdInput.fill(testCase.disabilityId);
      await page.waitForTimeout(TIMEOUTS.VERY_SHORT);

      // 验证下拉框未自动填充（仍显示默认占位符）
      const disabilityTypeTrigger = page.locator('[data-testid="disability-type-select"]');
      const typeText = await disabilityTypeTrigger.textContent();
      expect(typeText).toContain('请选择');
      expect(typeText).not.toContain('视力残疾');
      expect(typeText).not.toContain('听力残疾');
      expect(typeText).not.toContain('言语残疾');
      expect(typeText).not.toContain('肢体残疾');
      expect(typeText).not.toContain('智力残疾');
      expect(typeText).not.toContain('精神残疾');
      expect(typeText).not.toContain('多重残疾');

      console.debug('✅ 测试通过：长度不足时不自动填充');
    });

    test('残疾类别编码超出范围（8），不应自动填充类别', async ({ disabilityPersonPage, page }) => {
      const testData = generateTestPerson();
      const testCase = testCases.invalid.invalidTypeCode;

      console.debug('\n========== 测试：类别编码超出范围不自动填充 ==========');

      await disabilityPersonPage.openCreateDialog();

      const form = page.locator('form#create-form');
      await form.waitFor({ state: 'visible', timeout: TIMEOUTS.DIALOG });

      await form.getByLabel('姓名 *').fill(testData.name);
      // 性别 - 使用 Radix UI Select 方式
      const genderTrigger = page.locator('[data-testid="gender-select"]');
      await genderTrigger.click();
      await page.getByRole('option', { name: testData.gender }).click();
      await form.getByLabel('身份证号 *').fill(testData.idCard);

      // 输入类别编码无效的残疾证号
      const disabilityIdInput = form.getByLabel('残疾证号 *');
      await disabilityIdInput.fill(testCase.disabilityId);
      await page.waitForTimeout(TIMEOUTS.VERY_SHORT);

      // 验证残疾类别未自动填充
      const disabilityTypeTrigger = page.locator('[data-testid="disability-type-select"]');
      const typeText = await disabilityTypeTrigger.textContent();
      expect(typeText).toContain('请选择');
      expect(typeText).not.toContain('视力残疾');

      console.debug('✅ 测试通过：类别编码超出范围时不自动填充类别');
    });

    test('残疾等级编码超出范围（5），不应自动填充等级', async ({ disabilityPersonPage, page }) => {
      const testData = generateTestPerson();
      const testCase = testCases.invalid.invalidLevelCode;

      console.debug('\n========== 测试：等级编码超出范围不自动填充 ==========');

      await disabilityPersonPage.openCreateDialog();

      const form = page.locator('form#create-form');
      await form.waitFor({ state: 'visible', timeout: TIMEOUTS.DIALOG });

      await form.getByLabel('姓名 *').fill(testData.name);
      // 性别 - 使用 Radix UI Select 方式
      const genderTrigger = page.locator('[data-testid="gender-select"]');
      await genderTrigger.click();
      await page.getByRole('option', { name: testData.gender }).click();
      await form.getByLabel('身份证号 *').fill(testData.idCard);

      // 输入等级编码无效的残疾证号
      const disabilityIdInput = form.getByLabel('残疾证号 *');
      await disabilityIdInput.fill(testCase.disabilityId);
      await page.waitForTimeout(TIMEOUTS.VERY_SHORT);

      // 验证残疾等级未自动填充
      const disabilityLevelTrigger = page.locator('[data-testid="disability-level-select"]');
      const levelText = await disabilityLevelTrigger.textContent();
      expect(levelText).toContain('请选择');
      expect(levelText).not.toContain('一级');

      console.debug('✅ 测试通过：等级编码超出范围时不自动填充等级');
    });
  });

  test.describe('AC4: 用户可以手动修改自动填充的值', () => {
    test('自动填充后，用户应该能够手动修改残疾类别和等级', async ({ disabilityPersonPage, page }) => {
      const testData = generateTestPerson();
      const testCase = testCases.valid.visionLevel1;

      console.debug('\n========== 测试：自动填充后手动修改 ==========');

      await disabilityPersonPage.openCreateDialog();

      const form = page.locator('form#create-form');
      await form.waitFor({ state: 'visible', timeout: TIMEOUTS.DIALOG });

      await form.getByLabel('姓名 *').fill(testData.name);
      // 性别 - 使用 Radix UI Select 方式
      const genderTrigger = page.locator('[data-testid="gender-select"]');
      await genderTrigger.click();
      await page.getByRole('option', { name: testData.gender }).click();
      await form.getByLabel('身份证号 *').fill(testData.idCard);

      // 输入残疾证号触发自动填充
      const disabilityIdInput = form.getByLabel('残疾证号 *');
      await disabilityIdInput.fill(testCase.disabilityId);
      await page.waitForTimeout(TIMEOUTS.VERY_SHORT);

      // 验证自动填充
      const disabilityTypeTrigger = page.locator('[data-testid="disability-type-select"]');
      let autoFillTypeText = await disabilityTypeTrigger.textContent();
      expect(autoFillTypeText).toContain(testCase.expectedType);
      console.debug('✓ 残疾类别自动填充:', testCase.expectedType);

      // 手动修改残疾类别
      await disabilityTypeTrigger.click();
      await page.getByRole('option', { name: '肢体残疾' }).click();
      console.debug('✓ 残疾类别已手动修改为: 肢体残疾');

      // 验证修改成功
      const modifiedTypeText = await disabilityTypeTrigger.textContent();
      expect(modifiedTypeText).toContain('肢体残疾');
      expect(modifiedTypeText).not.toContain(testCase.expectedType);

      // 手动修改残疾等级
      const disabilityLevelTrigger = page.locator('[data-testid="disability-level-select"]');
      await disabilityLevelTrigger.click();
      await page.getByRole('option', { name: '三级' }).click();
      console.debug('✓ 残疾等级已手动修改为: 三级');

      // 验证修改成功
      const modifiedLevelText = await disabilityLevelTrigger.textContent();
      expect(modifiedLevelText).toContain('三级');
      expect(modifiedLevelText).not.toContain(testCase.expectedLevel);

      console.debug('✅ 测试通过：自动填充后可以手动修改');
    });
  });

  test.describe('清空残疾证号，验证下拉框恢复默认状态', () => {
    test('清空残疾证号后，下拉框应该保持用户选择的值', async ({ disabilityPersonPage, page }) => {
      const testData = generateTestPerson();
      const testCase = testCases.valid.visionLevel1;

      console.debug('\n========== 测试：清空残疾证号后的行为 ==========');

      await disabilityPersonPage.openCreateDialog();

      const form = page.locator('form#create-form');
      await form.waitFor({ state: 'visible', timeout: TIMEOUTS.DIALOG });

      await form.getByLabel('姓名 *').fill(testData.name);
      // 性别 - 使用 Radix UI Select 方式
      const genderTrigger = page.locator('[data-testid="gender-select"]');
      await genderTrigger.click();
      await page.getByRole('option', { name: testData.gender }).click();
      await form.getByLabel('身份证号 *').fill(testData.idCard);

      // 输入残疾证号触发自动填充
      const disabilityIdInput = form.getByLabel('残疾证号 *');
      await disabilityIdInput.fill(testCase.disabilityId);
      await page.waitForTimeout(TIMEOUTS.VERY_SHORT);

      // 验证自动填充
      const disabilityTypeTrigger = page.locator('[data-testid="disability-type-select"]');
      let autoFillTypeText = await disabilityTypeTrigger.textContent();
      expect(autoFillTypeText).toContain(testCase.expectedType);

      // 手动修改为其他值
      await disabilityTypeTrigger.click();
      await page.getByRole('option', { name: '肢体残疾' }).click();

      // 清空残疾证号
      await disabilityIdInput.fill('');
      await page.waitForTimeout(TIMEOUTS.VERY_SHORT);

      // 验证下拉框保持用户选择的值（肢体残疾），而不是恢复默认
      const finalTypeText = await disabilityTypeTrigger.textContent();
      expect(finalTypeText).toContain('肢体残疾');
      expect(finalTypeText).not.toContain('请选择');

      console.debug('✅ 测试通过：清空残疾证号后，下拉框保持用户选择的值');
    });
  });

  test.describe('编辑表单中的自动填充', () => {
    test('编辑表单也应该支持残疾证号自动填充', async ({ disabilityPersonPage, page }) => {
      const testData = generateTestPerson();
      const testCase = testCases.valid.visionLevel1;

      console.debug('\n========== 测试：编辑表单中的自动填充 ==========');

      // 1. 先创建一个测试用户（简化：跳过省市选择，使用最小必填字段）
      await disabilityPersonPage.openCreateDialog();

      const form = page.locator('form#create-form');
      await form.waitFor({ state: 'visible', timeout: TIMEOUTS.DIALOG });

      await form.getByLabel('姓名 *').fill(testData.name);
      // 性别 - 使用 Radix UI Select 方式
      const genderTrigger = page.locator('[data-testid="gender-select"]');
      await genderTrigger.click();
      await page.getByRole('option', { name: testData.gender }).click();
      await form.getByLabel('身份证号 *').fill(testData.idCard);
      await form.getByLabel('残疾证号 *').fill('123456789012345678'); // 临时值
      await form.getByLabel('联系电话 *').fill(testData.phone);
      await form.getByLabel('身份证地址 *').fill(testData.idAddress);

      // 选择省份（第一项）- 跳过城市选择以简化测试
      const provinceTrigger = page.locator('[data-testid="area-select-province"]');
      await provinceTrigger.scrollIntoViewIfNeeded();
      await provinceTrigger.click();
      const firstProvinceOption = page.getByRole('option').first();
      if (await firstProvinceOption.count() > 0) {
        await firstProvinceOption.click();
      }

      // 提交表单
      await page.getByRole('button', { name: '创建' }).click();
      await page.waitForTimeout(TIMEOUTS.MEDIUM);

      // 2. 搜索并编辑刚创建的用户
      await disabilityPersonPage.goto();
      await disabilityPersonPage.searchByName(testData.name);
      await page.waitForTimeout(TIMEOUTS.VERY_SHORT);

      const editButton = page.getByRole('button', { name: /编辑/ }).first();
      const hasEditButton = await editButton.count() > 0;

      if (hasEditButton) {
        await editButton.click();
        await page.waitForSelector('[data-testid="edit-disabled-person-dialog-title"]', { state: 'visible', timeout: TIMEOUTS.DIALOG });

        console.debug('✓ 编辑对话框已打开');

        // 3. 在编辑表单中输入新的残疾证号
        const editForm = page.locator('form#update-form');
        await editForm.waitFor({ state: 'visible', timeout: TIMEOUTS.DIALOG });

        const disabilityIdInput = editForm.getByLabel('残疾证号 *');
        await disabilityIdInput.fill('');
        await page.waitForTimeout(TIMEOUTS.VERY_SHORT);
        await disabilityIdInput.fill(testCase.disabilityId);
        console.debug('✓ 残疾证号已输入:', testCase.disabilityId);

        await page.waitForTimeout(TIMEOUTS.VERY_SHORT);

        // 4. 验证自动填充（编辑表单同样使用 Radix UI Select）
        const disabilityTypeTrigger = editForm.locator('[data-testid="disability-type-select"]');
        const selectedTypeText = await disabilityTypeTrigger.textContent();
        expect(selectedTypeText).toContain(testCase.expectedType);
        console.debug('✓ 残疾类别已自动填充:', testCase.expectedType);

        // 验证残疾等级
        const disabilityLevelTrigger = editForm.locator('[data-testid="disability-level-select"]');
        const selectedLevelText = await disabilityLevelTrigger.textContent();
        expect(selectedLevelText).toContain(testCase.expectedLevel);
        console.debug('✓ 残疾等级已自动填充:', testCase.expectedLevel);

        console.debug('✅ 测试通过：编辑表单支持残疾证号自动填充');
      } else {
        console.debug('ℹ️ 未找到编辑按钮（用户可能未创建成功），跳过验证');
      }
    });
  });
});