mini-starter/allin-packages/disability-person-management-ui/tests/utils/disabilityIdParser.test.ts

/**
 * 残疾证号解析工具函数单元测试
 */

import { describe, it, expect } from 'vitest';
import {
  parseDisabilityId,
  getStandardDisabilityTypes,
  getStandardDisabilityLevels,
  isValidDisabilityType,
  isValidDisabilityLevel,
  getDisabilityTypeByCode,
  getDisabilityLevelByCode
} from '../../src/utils/disabilityIdParser';

describe('disabilityIdParser', () => {
  describe('parseDisabilityId - 标准格式解析', () => {
    it('应该正确解析"视力残疾123456一级"格式', () => {
      const result = parseDisabilityId('视力残疾123456一级');
      expect(result.disabilityType).toBe('视力残疾');
      expect(result.disabilityLevel).toBe('一级');
      expect(result.isValid).toBe(true);
    });

    it('应该正确解析"肢体残疾987654二级"格式', () => {
      const result = parseDisabilityId('肢体残疾987654二级');
      expect(result.disabilityType).toBe('肢体残疾');
      expect(result.disabilityLevel).toBe('二级');
      expect(result.isValid).toBe(true);
    });

    it('应该正确解析"听力残疾111111三级"格式', () => {
      const result = parseDisabilityId('听力残疾111111三级');
      expect(result.disabilityType).toBe('听力残疾');
      expect(result.disabilityLevel).toBe('三级');
      expect(result.isValid).toBe(true);
    });

    it('应该正确解析"精神残疾222222四级"格式', () => {
      const result = parseDisabilityId('精神残疾222222四级');
      expect(result.disabilityType).toBe('精神残疾');
      expect(result.disabilityLevel).toBe('四级');
      expect(result.isValid).toBe(true);
    });
  });

  describe('parseDisabilityId - 简写格式解析', () => {
    it('应该正确解析"视力123456一级"简写格式', () => {
      const result = parseDisabilityId('视力123456一级');
      expect(result.disabilityType).toBe('视力残疾');
      expect(result.disabilityLevel).toBe('一级');
      expect(result.isValid).toBe(true);
    });

    it('应该正确解析"肢体987654二级"简写格式', () => {
      const result = parseDisabilityId('肢体987654二级');
      expect(result.disabilityType).toBe('肢体残疾');
      expect(result.disabilityLevel).toBe('二级');
      expect(result.isValid).toBe(true);
    });

    it('应该正确解析"言语111111三级"简写格式', () => {
      const result = parseDisabilityId('言语111111三级');
      expect(result.disabilityType).toBe('言语残疾');
      expect(result.disabilityLevel).toBe('三级');
      expect(result.isValid).toBe(true);
    });
  });

  describe('parseDisabilityId - 数字等级格式', () => {
    it('应该正确解析"视力1234561级"格式', () => {
      const result = parseDisabilityId('视力1234561级');
      expect(result.disabilityType).toBe('视力残疾');
      expect(result.disabilityLevel).toBe('一级');
      expect(result.isValid).toBe(true);
    });

    it('应该正确解析"肢体9876542级"格式', () => {
      const result = parseDisabilityId('肢体9876542级');
      expect(result.disabilityType).toBe('肢体残疾');
      expect(result.disabilityLevel).toBe('二级');
      expect(result.isValid).toBe(true);
    });
  });

  describe('parseDisabilityId - 部分匹配', () => {
    it('应该只解析残疾类别，不解析等级', () => {
      const result = parseDisabilityId('视力残疾123456');
      expect(result.disabilityType).toBe('视力残疾');
      expect(result.disabilityLevel).toBeNull();
      expect(result.isValid).toBe(true); // 至少解析出一个字段
    });

    it('应该只解析等级，不解析类别', () => {
      const result = parseDisabilityId('123456一级');
      expect(result.disabilityType).toBeNull();
      expect(result.disabilityLevel).toBe('一级');
      expect(result.isValid).toBe(true);
    });
  });

  describe('parseDisabilityId - 边界情况', () => {
    it('应该处理空字符串', () => {
      const result = parseDisabilityId('');
      expect(result.disabilityType).toBeNull();
      expect(result.disabilityLevel).toBeNull();
      expect(result.isValid).toBe(false);
    });

    it('应该处理只有空格的字符串', () => {
      const result = parseDisabilityId('   ');
      expect(result.disabilityType).toBeNull();
      expect(result.disabilityLevel).toBeNull();
      expect(result.isValid).toBe(false);
    });

    it('应该处理无法匹配的格式', () => {
      const result = parseDisabilityId('ABC123');
      expect(result.disabilityType).toBeNull();
      expect(result.disabilityLevel).toBeNull();
      expect(result.isValid).toBe(false);
    });

    it('应该处理带空格的残疾证号', () => {
      const result = parseDisabilityId(' 视力残疾 123456 一级 ');
      expect(result.disabilityType).toBe('视力残疾');
      expect(result.disabilityLevel).toBe('一级');
      expect(result.isValid).toBe(true);
    });
  });

  describe('parseDisabilityId - 所有残疾类别', () => {
    it('应该正确解析所有七种残疾类别', () => {
      const types = [
        '视力残疾',
        '听力残疾',
        '言语残疾',
        '肢体残疾',
        '智力残疾',
        '精神残疾',
        '多重残疾'
      ];

      types.forEach(type => {
        const result = parseDisabilityId(`${type}123456一级`);
        expect(result.disabilityType).toBe(type);
        expect(result.isValid).toBe(true);
      });
    });
  });

  describe('getStandardDisabilityTypes', () => {
    it('应该返回所有七种标准残疾类别', () => {
      const types = getStandardDisabilityTypes();
      expect(types).toEqual([
        '视力残疾',
        '听力残疾',
        '言语残疾',
        '肢体残疾',
        '智力残疾',
        '精神残疾',
        '多重残疾'
      ]);
    });
  });

  describe('getStandardDisabilityLevels', () => {
    it('应该返回所有四种标准残疾等级', () => {
      const levels = getStandardDisabilityLevels();
      expect(levels).toEqual(['一级', '二级', '三级', '四级']);
    });
  });

  describe('isValidDisabilityType', () => {
    it('应该验证有效的残疾类别', () => {
      expect(isValidDisabilityType('视力残疾')).toBe(true);
      expect(isValidDisabilityType('肢体残疾')).toBe(true);
      expect(isValidDisabilityType('多重残疾')).toBe(true);
    });

    it('应该拒绝无效的残疾类别', () => {
      expect(isValidDisabilityType('其他残疾')).toBe(false);
      expect(isValidDisabilityType('视力')).toBe(false);
      expect(isValidDisabilityType('')).toBe(false);
    });
  });

  describe('isValidDisabilityLevel', () => {
    it('应该验证有效的残疾等级', () => {
      expect(isValidDisabilityLevel('一级')).toBe(true);
      expect(isValidDisabilityLevel('二级')).toBe(true);
      expect(isValidDisabilityLevel('三级')).toBe(true);
      expect(isValidDisabilityLevel('四级')).toBe(true);
    });

    it('应该拒绝无效的残疾等级', () => {
      expect(isValidDisabilityLevel('五级')).toBe(false);
      expect(isValidDisabilityLevel('1级')).toBe(false);
      expect(isValidDisabilityLevel('')).toBe(false);
    });
  });

  describe('parseDisabilityId - 数字编码格式 (20位)', () => {
    it('应该正确解析20位数字编码格式 - 视力残疾一级', () => {
      // 格式: [18位身份证][类别编码1][等级编码1]
      const result = parseDisabilityId('11010119900101123411');
      expect(result.disabilityType).toBe('视力残疾');
      expect(result.disabilityLevel).toBe('一级');
      expect(result.isValid).toBe(true);
    });

    it('应该正确解析20位数字编码格式 - 听力残疾二级', () => {
      const result = parseDisabilityId('11010119900101123422');
      expect(result.disabilityType).toBe('听力残疾');
      expect(result.disabilityLevel).toBe('二级');
      expect(result.isValid).toBe(true);
    });

    it('应该正确解析20位数字编码格式 - 肢体残疾三级', () => {
      const result = parseDisabilityId('11010119900101123443');
      expect(result.disabilityType).toBe('肢体残疾');
      expect(result.disabilityLevel).toBe('三级');
      expect(result.isValid).toBe(true);
    });

    it('应该正确解析20位数字编码格式 - 精神残疾四级', () => {
      const result = parseDisabilityId('11010119900101123464');
      expect(result.disabilityType).toBe('精神残疾');
      expect(result.disabilityLevel).toBe('四级');
      expect(result.isValid).toBe(true);
    });
  });

  describe('parseDisabilityId - 所有残疾类别编码', () => {
    const categoryTests = [
      { code: '1', name: '视力残疾' },
      { code: '2', name: '听力残疾' },
      { code: '3', name: '言语残疾' },
      { code: '4', name: '肢体残疾' },
      { code: '5', name: '智力残疾' },
      { code: '6', name: '精神残疾' },
      { code: '7', name: '多重残疾' }
    ];

    categoryTests.forEach(({ code, name }) => {
      it(`应该正确解析类别编码 ${code} 为 ${name}`, () => {
        // 使用一级等级编码 (1)
        const result = parseDisabilityId(`110101199001011234${code}1`);
        expect(result.disabilityType).toBe(name);
        expect(result.isValid).toBe(true);
      });
    });
  });

  describe('parseDisabilityId - 所有残疾等级编码', () => {
    const levelTests = [
      { code: '1', name: '一级' },
      { code: '2', name: '二级' },
      { code: '3', name: '三级' },
      { code: '4', name: '四级' }
    ];

    levelTests.forEach(({ code, name }) => {
      it(`应该正确解析等级编码 ${code} 为 ${name}`, () => {
        // 使用视力类别编码 (1)
        const result = parseDisabilityId(`1101011990010112341${code}`);
        expect(result.disabilityLevel).toBe(name);
        expect(result.isValid).toBe(true);
      });
    });
  });

  describe('parseDisabilityId - 数字编码边界情况', () => {
    it('应该拒绝长度不足20位的数字', () => {
      const result = parseDisabilityId('1101011990010112341'); // 19位
      expect(result.disabilityType).toBeNull();
      expect(result.disabilityLevel).toBeNull();
      expect(result.isValid).toBe(false);
    });

    it('应该拒绝长度超过20位的数字', () => {
      const result = parseDisabilityId('110101199001011234111'); // 21位
      expect(result.disabilityType).toBeNull();
      expect(result.disabilityLevel).toBeNull();
      expect(result.isValid).toBe(false);
    });

    it('应该拒绝包含非数字字符的20位字符串', () => {
      const result = parseDisabilityId('1101011990010112341A');
      expect(result.disabilityType).toBeNull();
      expect(result.disabilityLevel).toBeNull();
      expect(result.isValid).toBe(false);
    });

    it('应该拒绝无效的残疾类别编码', () => {
      // 类别编码为 8（无效），等级编码为 1（有效）
      const result = parseDisabilityId('11010119900101123481');
      expect(result.disabilityType).toBeNull();
      expect(result.disabilityLevel).toBe('一级');
      expect(result.isValid).toBe(true); // 至少解析出一个字段
    });

    it('应该拒绝无效的残疾等级编码', () => {
      // 类别编码为 1（有效），等级编码为 5（无效）
      const result = parseDisabilityId('11010119900101123415');
      expect(result.disabilityType).toBe('视力残疾');
      expect(result.disabilityLevel).toBeNull();
      expect(result.isValid).toBe(true); // 至少解析出一个字段
    });

    it('应该拒绝两个编码都无效的情况', () => {
      // 类别编码为 8（无效），等级编码为 9（无效）
      const result = parseDisabilityId('11010119900101123489');
      expect(result.disabilityType).toBeNull();
      expect(result.disabilityLevel).toBeNull();
      expect(result.isValid).toBe(false);
    });

    it('应该拒绝类别编码为 0 的情况', () => {
      const result = parseDisabilityId('11010119900101123401');
      expect(result.disabilityType).toBeNull();
      expect(result.disabilityLevel).toBe('一级');
      expect(result.isValid).toBe(true); // 等级编码有效
    });

    it('应该拒绝等级编码为 0 的情况', () => {
      const result = parseDisabilityId('11010119900101123410');
      expect(result.disabilityType).toBe('视力残疾');
      expect(result.disabilityLevel).toBeNull();
      expect(result.isValid).toBe(true); // 类别编码有效
    });
  });

  describe('parseDisabilityId - 数字编码与文本格式优先级', () => {
    it('应该优先使用数字编码格式解析', () => {
      // 20位纯数字应该被识别为数字编码格式
      const result = parseDisabilityId('11010119900101123411');
      expect(result.disabilityType).toBe('视力残疾');
      expect(result.disabilityLevel).toBe('一级');
      expect(result.isValid).toBe(true);
    });

    it('应该对非20位数字回退到文本格式解析', () => {
      // 包含文字的格式应该回退到文本解析
      const result = parseDisabilityId('视力残疾123456一级');
      expect(result.disabilityType).toBe('视力残疾');
      expect(result.disabilityLevel).toBe('一级');
      expect(result.isValid).toBe(true);
    });
  });

  describe('getDisabilityTypeByCode', () => {
    it('应该返回正确的残疾类别', () => {
      expect(getDisabilityTypeByCode('1')).toBe('视力残疾');
      expect(getDisabilityTypeByCode('2')).toBe('听力残疾');
      expect(getDisabilityTypeByCode('3')).toBe('言语残疾');
      expect(getDisabilityTypeByCode('4')).toBe('肢体残疾');
      expect(getDisabilityTypeByCode('5')).toBe('智力残疾');
      expect(getDisabilityTypeByCode('6')).toBe('精神残疾');
      expect(getDisabilityTypeByCode('7')).toBe('多重残疾');
    });

    it('应该对无效编码返回 null', () => {
      expect(getDisabilityTypeByCode('0')).toBeNull();
      expect(getDisabilityTypeByCode('8')).toBeNull();
      expect(getDisabilityTypeByCode('9')).toBeNull();
      expect(getDisabilityTypeByCode('')).toBeNull();
      expect(getDisabilityTypeByCode('abc')).toBeNull();
    });
  });

  describe('getDisabilityLevelByCode', () => {
    it('应该返回正确的残疾等级', () => {
      expect(getDisabilityLevelByCode('1')).toBe('一级');
      expect(getDisabilityLevelByCode('2')).toBe('二级');
      expect(getDisabilityLevelByCode('3')).toBe('三级');
      expect(getDisabilityLevelByCode('4')).toBe('四级');
    });

    it('应该对无效编码返回 null', () => {
      expect(getDisabilityLevelByCode('0')).toBeNull();
      expect(getDisabilityLevelByCode('5')).toBeNull();
      expect(getDisabilityLevelByCode('9')).toBeNull();
      expect(getDisabilityLevelByCode('')).toBeNull();
      expect(getDisabilityLevelByCode('abc')).toBeNull();
    });
  });
});