knowai/test/unit/utils/validation.test.ts

import { describe, it, expect } from 'vitest';
import { validationUtils } from '@/utils/validation';

describe('validationUtils', () => {
  describe('isEmail', () => {
    it('应该验证有效的邮箱地址', () => {
      expect(validationUtils.isEmail('test@example.com')).toBe(true);
      expect(validationUtils.isEmail('user.name@domain.co.uk')).toBe(true);
      expect(validationUtils.isEmail('user+tag@example.org')).toBe(true);
    });

    it('应该拒绝无效的邮箱地址', () => {
      expect(validationUtils.isEmail('')).toBe(false);
      expect(validationUtils.isEmail('test')).toBe(false);
      expect(validationUtils.isEmail('test@')).toBe(false);
      expect(validationUtils.isEmail('@example.com')).toBe(false);
      expect(validationUtils.isEmail('test@.com')).toBe(false);
      expect(validationUtils.isEmail('test@example')).toBe(false);
      expect(validationUtils.isEmail('test example.com')).toBe(false);
    });
  });

  describe('isPhoneNumber', () => {
    it('应该验证有效的手机号（中国大陆）', () => {
      expect(validationUtils.isPhoneNumber('13812345678')).toBe(true);
      expect(validationUtils.isPhoneNumber('15987654321')).toBe(true);
      expect(validationUtils.isPhoneNumber('18612345678')).toBe(true);
    });

    it('应该拒绝无效的手机号', () => {
      expect(validationUtils.isPhoneNumber('')).toBe(false);
      expect(validationUtils.isPhoneNumber('12345678901')).toBe(false);
      expect(validationUtils.isPhoneNumber('12812345678')).toBe(false);
      expect(validationUtils.isPhoneNumber('1381234567')).toBe(false);
      expect(validationUtils.isPhoneNumber('138123456789')).toBe(false);
      expect(validationUtils.isPhoneNumber('abcdefghijk')).toBe(false);
    });
  });

  describe('isIdCard', () => {
    it('应该验证有效的身份证号（中国大陆）', () => {
      expect(validationUtils.isIdCard('123456789012345')).toBe(true); // 15位
      expect(validationUtils.isIdCard('123456789012345678')).toBe(true); // 18位数字
      expect(validationUtils.isIdCard('12345678901234567X')).toBe(true); // 18位以X结尾
      expect(validationUtils.isIdCard('12345678901234567x')).toBe(true); // 18位以x结尾
    });

    it('应该拒绝无效的身份证号', () => {
      expect(validationUtils.isIdCard('')).toBe(false);
      expect(validationUtils.isIdCard('12345678901234')).toBe(false); // 14位
      expect(validationUtils.isIdCard('1234567890123456')).toBe(false); // 16位
      expect(validationUtils.isIdCard('1234567890123456789')).toBe(false); // 19位
      expect(validationUtils.isIdCard('12345678901234567Y')).toBe(false); // 18位以Y结尾
    });
  });

  describe('isStrongPassword', () => {
    it('应该验证强密码', () => {
      expect(validationUtils.isStrongPassword('Password123!')).toBe(true);
      expect(validationUtils.isStrongPassword('StrongPass@2023')).toBe(true);
      expect(validationUtils.isStrongPassword('Pass123!')).toBe(true);
    });

    it('应该拒绝弱密码', () => {
      expect(validationUtils.isStrongPassword('')).toBe(false);
      expect(validationUtils.isStrongPassword('password')).toBe(false); // 没有大写字母、数字和特殊字符
      expect(validationUtils.isStrongPassword('PASSWORD')).toBe(false); // 没有小写字母、数字和特殊字符
      expect(validationUtils.isStrongPassword('12345678')).toBe(false); // 没有字母和特殊字符
      expect(validationUtils.isStrongPassword('Password')).toBe(false); // 没有数字和特殊字符
      expect(validationUtils.isStrongPassword('Password123')).toBe(false); // 没有特殊字符
    });
  });

  describe('isEmpty', () => {
    it('应该识别空值', () => {
      expect(validationUtils.isEmpty(null)).toBe(true);
      expect(validationUtils.isEmpty(undefined)).toBe(true);
      expect(validationUtils.isEmpty('')).toBe(true);
      expect(validationUtils.isEmpty('   ')).toBe(true);
      expect(validationUtils.isEmpty([])).toBe(true);
      expect(validationUtils.isEmpty({})).toBe(true);
    });

    it('应该识别非空值', () => {
      expect(validationUtils.isEmpty('text')).toBe(false);
      expect(validationUtils.isEmpty(' text ')).toBe(false);
      expect(validationUtils.isEmpty([1, 2, 3])).toBe(false);
      expect(validationUtils.isEmpty({ key: 'value' })).toBe(false);
      expect(validationUtils.isEmpty(0)).toBe(false);
      expect(validationUtils.isEmpty(false)).toBe(false);
    });
  });

  describe('isInRange', () => {
    it('应该验证范围内的数字', () => {
      expect(validationUtils.isInRange(5, 1, 10)).toBe(true);
      expect(validationUtils.isInRange(1, 1, 10)).toBe(true);
      expect(validationUtils.isInRange(10, 1, 10)).toBe(true);
    });

    it('应该拒绝超出范围的数字', () => {
      expect(validationUtils.isInRange(0, 1, 10)).toBe(false);
      expect(validationUtils.isInRange(11, 1, 10)).toBe(false);
    });
  });

  describe('isLengthValid', () => {
    it('应该验证有效长度', () => {
      expect(validationUtils.isLengthValid('hello', 3, 10)).toBe(true);
      expect(validationUtils.isLengthValid('hello', 5)).toBe(true);
      expect(validationUtils.isLengthValid('hello', 1, 5)).toBe(true);
    });

    it('应该拒绝无效长度', () => {
      expect(validationUtils.isLengthValid('hello', 6, 10)).toBe(false); // 太短
      expect(validationUtils.isLengthValid('hello', 1, 4)).toBe(false); // 太长
      expect(validationUtils.isLengthValid('', 1, 10)).toBe(false); // 太短
    });

    it('应该处理只有最小长度的情况', () => {
      expect(validationUtils.isLengthValid('hello', 5)).toBe(true);
      expect(validationUtils.isLengthValid('hello', 6)).toBe(false);
    });
  });

  describe('isNumber', () => {
    it('应该验证数字', () => {
      expect(validationUtils.isNumber(0)).toBe(true);
      expect(validationUtils.isNumber(123)).toBe(true);
      expect(validationUtils.isNumber(-456)).toBe(true);
      expect(validationUtils.isNumber(3.14)).toBe(true);
    });

    it('应该拒绝非数字', () => {
      expect(validationUtils.isNumber('123')).toBe(false);
      expect(validationUtils.isNumber(NaN)).toBe(false);
      expect(validationUtils.isNumber(Infinity)).toBe(true); // Infinity被认为是数字
      expect(validationUtils.isNumber(null)).toBe(false);
      expect(validationUtils.isNumber(undefined)).toBe(false);
    });
  });

  describe('isInteger', () => {
    it('应该验证整数', () => {
      expect(validationUtils.isInteger(0)).toBe(true);
      expect(validationUtils.isInteger(123)).toBe(true);
      expect(validationUtils.isInteger(-456)).toBe(true);
    });

    it('应该拒绝非整数', () => {
      expect(validationUtils.isInteger(3.14)).toBe(false);
      expect(validationUtils.isInteger('123')).toBe(false);
      expect(validationUtils.isInteger(NaN)).toBe(false);
      expect(validationUtils.isInteger(null)).toBe(false);
    });
  });

  describe('isPositive', () => {
    it('应该验证正数', () => {
      expect(validationUtils.isPositive(1)).toBe(true);
      expect(validationUtils.isPositive(123.456)).toBe(true);
    });

    it('应该拒绝非正数', () => {
      expect(validationUtils.isPositive(0)).toBe(false);
      expect(validationUtils.isPositive(-1)).toBe(false);
      expect(validationUtils.isPositive(-123.456)).toBe(false);
    });
  });

  describe('isNegative', () => {
    it('应该验证负数', () => {
      expect(validationUtils.isNegative(-1)).toBe(true);
      expect(validationUtils.isNegative(-123.456)).toBe(true);
    });

    it('应该拒绝非负数', () => {
      expect(validationUtils.isNegative(0)).toBe(false);
      expect(validationUtils.isNegative(1)).toBe(false);
      expect(validationUtils.isNegative(123.456)).toBe(false);
    });
  });

  describe('isEven', () => {
    it('应该验证偶数', () => {
      expect(validationUtils.isEven(0)).toBe(true);
      expect(validationUtils.isEven(2)).toBe(true);
      expect(validationUtils.isEven(-4)).toBe(true);
    });

    it('应该拒绝奇数', () => {
      expect(validationUtils.isEven(1)).toBe(false);
      expect(validationUtils.isEven(3)).toBe(false);
      expect(validationUtils.isEven(-5)).toBe(false);
    });
  });

  describe('isOdd', () => {
    it('应该验证奇数', () => {
      expect(validationUtils.isOdd(1)).toBe(true);
      expect(validationUtils.isOdd(3)).toBe(true);
      expect(validationUtils.isOdd(-5)).toBe(true);
    });

    it('应该拒绝偶数', () => {
      expect(validationUtils.isOdd(0)).toBe(false);
      expect(validationUtils.isOdd(2)).toBe(false);
      expect(validationUtils.isOdd(-4)).toBe(false);
    });
  });

  describe('isLeapYear', () => {
    it('应该验证闰年', () => {
      expect(validationUtils.isLeapYear(2000)).toBe(true); // 能被400整除
      expect(validationUtils.isLeapYear(2020)).toBe(true); // 能被4整除但不能被100整除
    });

    it('应该拒绝非闰年', () => {
      expect(validationUtils.isLeapYear(1900)).toBe(false); // 能被100整除但不能被400整除
      expect(validationUtils.isLeapYear(2023)).toBe(false); // 不能被4整除
    });
  });

});