@dangao/bun-server 1.7.1 → 1.8.1

package/tests/validation/class-validator.test.ts

@@ -0,0 +1,349 @@
+import { describe, expect, test } from 'bun:test';
+import 'reflect-metadata';
+
+import {
+  ValidateClass,
+  Property,
+  NestedProperty,
+  ArrayNestedProperty,
+  validateObject,
+  validateObjectSync,
+  getClassValidationMetadata,
+  isValidateClass,
+  IsString,
+  IsEmail,
+  IsNumber,
+  IsOptional,
+  MinLength,
+  IsInt,
+  Min,
+  Max,
+  IsArray,
+  ArrayMinSize,
+  IsNotEmpty,
+  ValidationError,
+} from '../../src/validation';
+
+describe('Class Validator', () => {
+  describe('ValidateClass decorator', () => {
+    test('should mark class as validate class', () => {
+      @ValidateClass()
+      class TestDto {
+        public name: string = '';
+      }
+
+      expect(isValidateClass(TestDto)).toBe(true);
+    });
+
+    test('should return false for non-decorated class', () => {
+      class TestDto {
+        public name: string = '';
+      }
+
+      expect(isValidateClass(TestDto)).toBe(false);
+    });
+  });
+
+  describe('Property decorator', () => {
+    test('should store validation metadata', () => {
+      @ValidateClass()
+      class TestDto {
+        @Property(IsString(), MinLength(2))
+        public name: string = '';
+
+        @Property(IsEmail())
+        public email: string = '';
+      }
+
+      const metadata = getClassValidationMetadata(TestDto);
+      expect(metadata.length).toBe(2);
+
+      const nameMetadata = metadata.find((m) => m.property === 'name');
+      expect(nameMetadata).toBeDefined();
+      expect(nameMetadata!.rules.length).toBe(2);
+      expect(nameMetadata!.rules[0].name).toBe('isString');
+      expect(nameMetadata!.rules[1].name).toBe('minLength');
+
+      const emailMetadata = metadata.find((m) => m.property === 'email');
+      expect(emailMetadata).toBeDefined();
+      expect(emailMetadata!.rules.length).toBe(1);
+      expect(emailMetadata!.rules[0].name).toBe('isEmail');
+    });
+  });
+
+  describe('validateObject', () => {
+    @ValidateClass()
+    class CreateUserDto {
+      @Property(IsString(), MinLength(2))
+      public name: string = '';
+
+      @Property(IsEmail())
+      public email: string = '';
+
+      @Property(IsOptional(), IsInt(), Min(0), Max(150))
+      public age?: number;
+    }
+
+    test('should pass for valid object', () => {
+      const dto = {
+        name: 'John',
+        email: 'john@example.com',
+        age: 25,
+      };
+
+      expect(() => validateObject(dto, CreateUserDto)).not.toThrow();
+    });
+
+    test('should pass for valid object without optional fields', () => {
+      const dto = {
+        name: 'John',
+        email: 'john@example.com',
+      };
+
+      expect(() => validateObject(dto, CreateUserDto)).not.toThrow();
+    });
+
+    test('should throw ValidationError for invalid name', () => {
+      const dto = {
+        name: 'A',
+        email: 'john@example.com',
+      };
+
+      expect(() => validateObject(dto, CreateUserDto)).toThrow(ValidationError);
+    });
+
+    test('should throw ValidationError for invalid email', () => {
+      const dto = {
+        name: 'John',
+        email: 'invalid-email',
+      };
+
+      expect(() => validateObject(dto, CreateUserDto)).toThrow(ValidationError);
+    });
+
+    test('should throw ValidationError for invalid age', () => {
+      const dto = {
+        name: 'John',
+        email: 'john@example.com',
+        age: -1,
+      };
+
+      expect(() => validateObject(dto, CreateUserDto)).toThrow(ValidationError);
+    });
+
+    test('should collect all errors', () => {
+      const dto = {
+        name: 'A',
+        email: 'invalid',
+        age: -1,
+      };
+
+      try {
+        validateObject(dto, CreateUserDto);
+        expect(true).toBe(false); // Should not reach here
+      } catch (error) {
+        expect(error).toBeInstanceOf(ValidationError);
+        const validationError = error as ValidationError;
+        expect(validationError.issues.length).toBeGreaterThanOrEqual(3);
+      }
+    });
+
+    test('should stop at first error when stopAtFirstError is true', () => {
+      const dto = {
+        name: 'A',
+        email: 'invalid',
+        age: -1,
+      };
+
+      try {
+        validateObject(dto, CreateUserDto, { stopAtFirstError: true });
+        expect(true).toBe(false);
+      } catch (error) {
+        expect(error).toBeInstanceOf(ValidationError);
+        const validationError = error as ValidationError;
+        expect(validationError.issues.length).toBe(1);
+      }
+    });
+  });
+
+  describe('validateObjectSync', () => {
+    @ValidateClass()
+    class SimpleDto {
+      @Property(IsString())
+      public name: string = '';
+    }
+
+    test('should return valid: true for valid object', () => {
+      const result = validateObjectSync({ name: 'test' }, SimpleDto);
+      expect(result.valid).toBe(true);
+      expect(result.issues.length).toBe(0);
+    });
+
+    test('should return valid: false with issues for invalid object', () => {
+      const result = validateObjectSync({ name: 123 }, SimpleDto);
+      expect(result.valid).toBe(false);
+      expect(result.issues.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('Nested validation', () => {
+    @ValidateClass()
+    class AddressDto {
+      @Property(IsString(), IsNotEmpty())
+      public city: string = '';
+
+      @Property(IsString(), IsNotEmpty())
+      public street: string = '';
+    }
+
+    @ValidateClass()
+    class UserWithAddressDto {
+      @Property(IsString(), MinLength(2))
+      public name: string = '';
+
+      @NestedProperty(AddressDto)
+      public address: AddressDto = new AddressDto();
+    }
+
+    test('should validate nested object', () => {
+      const dto = {
+        name: 'John',
+        address: {
+          city: 'Beijing',
+          street: 'Main St',
+        },
+      };
+
+      expect(() => validateObject(dto, UserWithAddressDto)).not.toThrow();
+    });
+
+    test('should fail for invalid nested object', () => {
+      const dto = {
+        name: 'John',
+        address: {
+          city: '',
+          street: 'Main St',
+        },
+      };
+
+      expect(() => validateObject(dto, UserWithAddressDto)).toThrow(ValidationError);
+    });
+
+    test('should include property path in error', () => {
+      const dto = {
+        name: 'John',
+        address: {
+          city: '',
+          street: '',
+        },
+      };
+
+      try {
+        validateObject(dto, UserWithAddressDto);
+        expect(true).toBe(false);
+      } catch (error) {
+        const validationError = error as ValidationError;
+        const cityError = validationError.issues.find((i) => i.property?.includes('city'));
+        expect(cityError).toBeDefined();
+      }
+    });
+  });
+
+  describe('Array nested validation', () => {
+    @ValidateClass()
+    class ItemDto {
+      @Property(IsString(), IsNotEmpty())
+      public name: string = '';
+
+      @Property(IsNumber(), Min(0))
+      public price: number = 0;
+    }
+
+    @ValidateClass()
+    class OrderDto {
+      @Property(IsString())
+      public orderId: string = '';
+
+      @Property(IsArray(), ArrayMinSize(1))
+      @ArrayNestedProperty(ItemDto)
+      public items: ItemDto[] = [];
+    }
+
+    test('should validate array of nested objects', () => {
+      const dto = {
+        orderId: '123',
+        items: [
+          { name: 'Item 1', price: 10 },
+          { name: 'Item 2', price: 20 },
+        ],
+      };
+
+      expect(() => validateObject(dto, OrderDto)).not.toThrow();
+    });
+
+    test('should fail for invalid item in array', () => {
+      const dto = {
+        orderId: '123',
+        items: [
+          { name: 'Item 1', price: 10 },
+          { name: '', price: -5 },
+        ],
+      };
+
+      expect(() => validateObject(dto, OrderDto)).toThrow(ValidationError);
+    });
+
+    test('should include array index in error path', () => {
+      const dto = {
+        orderId: '123',
+        items: [
+          { name: 'Item 1', price: 10 },
+          { name: '', price: 20 },
+        ],
+      };
+
+      try {
+        validateObject(dto, OrderDto);
+        expect(true).toBe(false);
+      } catch (error) {
+        const validationError = error as ValidationError;
+        const itemError = validationError.issues.find((i) => i.property?.includes('[1]'));
+        expect(itemError).toBeDefined();
+      }
+    });
+  });
+
+  describe('ValidationError methods', () => {
+    test('getFlattened should flatten nested errors', () => {
+      const issues = [
+        {
+          property: 'user',
+          rule: 'validateNested',
+          message: 'Nested validation failed',
+          children: [
+            { property: 'name', rule: 'isString', message: 'Must be string' },
+            { property: 'email', rule: 'isEmail', message: 'Must be email' },
+          ],
+        },
+      ];
+
+      const error = new ValidationError('Validation failed', issues);
+      const flattened = error.getFlattened();
+
+      expect(flattened.length).toBe(2);
+      expect(flattened[0].property).toBe('user.name');
+      expect(flattened[1].property).toBe('user.email');
+    });
+
+    test('toJSON should return serializable object', () => {
+      const error = new ValidationError('Test error', [
+        { property: 'name', rule: 'isString', message: 'Must be string' },
+      ]);
+
+      const json = error.toJSON();
+      expect(json.name).toBe('ValidationError');
+      expect(json.message).toBe('Test error');
+      expect(json.issues).toBeDefined();
+    });
+  });
+});

package/tests/validation/custom-validator.test.ts

@@ -0,0 +1,335 @@
+import { describe, expect, test } from 'bun:test';
+
+import {
+  createCustomValidator,
+  createSimpleValidator,
+  createRegexValidator,
+  // 内置扩展验证器
+  IsPhoneNumber,
+  IsIdCard,
+  IsIPv4,
+  IsPort,
+  IsPostalCode,
+  IsCreditCard,
+  IsHexColor,
+  IsMacAddress,
+  IsSemVer,
+  IsDivisibleBy,
+  IsBetween,
+  Contains,
+  NotContains,
+} from '../../src/validation';
+
+describe('Custom Validator Factory', () => {
+  describe('createCustomValidator', () => {
+    test('should create validator with arguments', () => {
+      const IsGreaterThan = createCustomValidator(
+        'isGreaterThan',
+        (value: unknown, min: number) => typeof value === 'number' && value > min,
+        (min: number) => `必须大于 ${min}`,
+      );
+
+      const rule = IsGreaterThan(10)();
+      expect(rule.name).toBe('isGreaterThan');
+      expect(rule.message).toBe('必须大于 10');
+      expect(rule.validate(11)).toBe(true);
+      expect(rule.validate(10)).toBe(false);
+      expect(rule.validate(5)).toBe(false);
+    });
+
+    test('should support custom message', () => {
+      const IsGreaterThan = createCustomValidator(
+        'isGreaterThan',
+        (value: unknown, min: number) => typeof value === 'number' && value > min,
+        (min: number) => `必须大于 ${min}`,
+      );
+
+      const rule = IsGreaterThan(5)({ message: 'Custom error message' });
+      expect(rule.message).toBe('Custom error message');
+    });
+
+    test('should support static message', () => {
+      const IsPositiveNumber = createCustomValidator(
+        'isPositiveNumber',
+        (value: unknown) => typeof value === 'number' && value > 0,
+        '必须是正数',
+      );
+
+      const rule = IsPositiveNumber()();
+      expect(rule.message).toBe('必须是正数');
+    });
+  });
+
+  describe('createSimpleValidator', () => {
+    test('should create simple validator without arguments', () => {
+      const IsEven = createSimpleValidator(
+        'isEven',
+        (value) => typeof value === 'number' && value % 2 === 0,
+        '必须是偶数',
+      );
+
+      const rule = IsEven();
+      expect(rule.name).toBe('isEven');
+      expect(rule.message).toBe('必须是偶数');
+      expect(rule.validate(2)).toBe(true);
+      expect(rule.validate(4)).toBe(true);
+      expect(rule.validate(3)).toBe(false);
+    });
+
+    test('should support custom message', () => {
+      const IsEven = createSimpleValidator(
+        'isEven',
+        (value) => typeof value === 'number' && value % 2 === 0,
+        '必须是偶数',
+      );
+
+      const rule = IsEven({ message: 'Value must be even' });
+      expect(rule.message).toBe('Value must be even');
+    });
+  });
+
+  describe('createRegexValidator', () => {
+    test('should create regex-based validator', () => {
+      const IsSlug = createRegexValidator(
+        'isSlug',
+        /^[a-z0-9]+(?:-[a-z0-9]+)*$/,
+        '必须是有效的 slug 格式',
+      );
+
+      const rule = IsSlug();
+      expect(rule.name).toBe('isSlug');
+      expect(rule.validate('hello-world')).toBe(true);
+      expect(rule.validate('test123')).toBe(true);
+      expect(rule.validate('Hello-World')).toBe(false);
+      expect(rule.validate('hello_world')).toBe(false);
+    });
+  });
+});
+
+describe('Built-in Extended Validators', () => {
+  describe('IsPhoneNumber', () => {
+    const rule = IsPhoneNumber();
+
+    test('should pass for valid Chinese phone numbers', () => {
+      expect(rule.validate('13812345678')).toBe(true);
+      expect(rule.validate('15912345678')).toBe(true);
+      expect(rule.validate('18612345678')).toBe(true);
+    });
+
+    test('should fail for invalid phone numbers', () => {
+      expect(rule.validate('12345678901')).toBe(false);
+      expect(rule.validate('1381234567')).toBe(false);
+      expect(rule.validate('138123456789')).toBe(false);
+      expect(rule.validate('abc12345678')).toBe(false);
+    });
+  });
+
+  describe('IsIdCard', () => {
+    const rule = IsIdCard();
+
+    test('should pass for valid ID cards', () => {
+      // 18位身份证
+      expect(rule.validate('110101199003078534')).toBe(true);
+      // 15位身份证
+      expect(rule.validate('110101900307853')).toBe(true);
+    });
+
+    test('should fail for invalid ID cards', () => {
+      expect(rule.validate('12345678901234567')).toBe(false);
+      expect(rule.validate('abc')).toBe(false);
+    });
+  });
+
+  describe('IsIPv4', () => {
+    const rule = IsIPv4();
+
+    test('should pass for valid IPv4 addresses', () => {
+      expect(rule.validate('192.168.1.1')).toBe(true);
+      expect(rule.validate('0.0.0.0')).toBe(true);
+      expect(rule.validate('255.255.255.255')).toBe(true);
+    });
+
+    test('should fail for invalid IPv4 addresses', () => {
+      expect(rule.validate('256.1.1.1')).toBe(false);
+      expect(rule.validate('192.168.1')).toBe(false);
+      expect(rule.validate('192.168.1.1.1')).toBe(false);
+      expect(rule.validate('192.168.1.01')).toBe(false); // Leading zero
+    });
+  });
+
+  describe('IsPort', () => {
+    const rule = IsPort();
+
+    test('should pass for valid ports', () => {
+      expect(rule.validate(0)).toBe(true);
+      expect(rule.validate(80)).toBe(true);
+      expect(rule.validate(443)).toBe(true);
+      expect(rule.validate(65535)).toBe(true);
+      expect(rule.validate('8080')).toBe(true);
+    });
+
+    test('should fail for invalid ports', () => {
+      expect(rule.validate(-1)).toBe(false);
+      expect(rule.validate(65536)).toBe(false);
+      expect(rule.validate('abc')).toBe(false);
+    });
+  });
+
+  describe('IsPostalCode', () => {
+    const rule = IsPostalCode();
+
+    test('should pass for valid Chinese postal codes', () => {
+      expect(rule.validate('100000')).toBe(true);
+      expect(rule.validate('518000')).toBe(true);
+    });
+
+    test('should fail for invalid postal codes', () => {
+      expect(rule.validate('010000')).toBe(false); // Starts with 0
+      expect(rule.validate('1000000')).toBe(false);
+      expect(rule.validate('12345')).toBe(false);
+    });
+  });
+
+  describe('IsCreditCard', () => {
+    const rule = IsCreditCard();
+
+    test('should pass for valid credit card numbers (Luhn check)', () => {
+      expect(rule.validate('4532015112830366')).toBe(true);
+      expect(rule.validate('4532-0151-1283-0366')).toBe(true);
+      expect(rule.validate('4532 0151 1283 0366')).toBe(true);
+    });
+
+    test('should fail for invalid credit card numbers', () => {
+      expect(rule.validate('1234567890123456')).toBe(false);
+      expect(rule.validate('abc')).toBe(false);
+    });
+  });
+
+  describe('IsHexColor', () => {
+    const rule = IsHexColor();
+
+    test('should pass for valid hex colors', () => {
+      expect(rule.validate('#fff')).toBe(true);
+      expect(rule.validate('#FFF')).toBe(true);
+      expect(rule.validate('#ffffff')).toBe(true);
+      expect(rule.validate('#FFFFFF')).toBe(true);
+    });
+
+    test('should fail for invalid hex colors', () => {
+      expect(rule.validate('fff')).toBe(false);
+      expect(rule.validate('#ffff')).toBe(false);
+      expect(rule.validate('#ggg')).toBe(false);
+    });
+  });
+
+  describe('IsMacAddress', () => {
+    const rule = IsMacAddress();
+
+    test('should pass for valid MAC addresses', () => {
+      expect(rule.validate('00:1A:2B:3C:4D:5E')).toBe(true);
+      expect(rule.validate('00-1A-2B-3C-4D-5E')).toBe(true);
+      expect(rule.validate('00:1a:2b:3c:4d:5e')).toBe(true);
+    });
+
+    test('should fail for invalid MAC addresses', () => {
+      expect(rule.validate('00:1A:2B:3C:4D')).toBe(false);
+      expect(rule.validate('00:1A:2B:3C:4D:5E:6F')).toBe(false);
+      expect(rule.validate('invalid')).toBe(false);
+    });
+  });
+
+  describe('IsSemVer', () => {
+    const rule = IsSemVer();
+
+    test('should pass for valid semantic versions', () => {
+      expect(rule.validate('1.0.0')).toBe(true);
+      expect(rule.validate('0.0.1')).toBe(true);
+      expect(rule.validate('1.0.0-alpha')).toBe(true);
+      expect(rule.validate('1.0.0-alpha.1')).toBe(true);
+      expect(rule.validate('1.0.0+build')).toBe(true);
+      expect(rule.validate('1.0.0-alpha+build')).toBe(true);
+    });
+
+    test('should fail for invalid semantic versions', () => {
+      expect(rule.validate('1.0')).toBe(false);
+      expect(rule.validate('1')).toBe(false);
+      expect(rule.validate('v1.0.0')).toBe(false);
+      expect(rule.validate('1.0.0.0')).toBe(false);
+    });
+  });
+
+  describe('IsDivisibleBy', () => {
+    test('should pass when divisible', () => {
+      const rule = IsDivisibleBy(5)();
+      expect(rule.validate(10)).toBe(true);
+      expect(rule.validate(15)).toBe(true);
+      expect(rule.validate(0)).toBe(true);
+    });
+
+    test('should fail when not divisible', () => {
+      const rule = IsDivisibleBy(5)();
+      expect(rule.validate(7)).toBe(false);
+      expect(rule.validate(12)).toBe(false);
+    });
+
+    test('should have correct message', () => {
+      const rule = IsDivisibleBy(3)();
+      expect(rule.message).toBe('必须能被 3 整除');
+    });
+  });
+
+  describe('IsBetween', () => {
+    test('should pass for values in range', () => {
+      const rule = IsBetween(1, 10)();
+      expect(rule.validate(1)).toBe(true);
+      expect(rule.validate(5)).toBe(true);
+      expect(rule.validate(10)).toBe(true);
+    });
+
+    test('should fail for values out of range', () => {
+      const rule = IsBetween(1, 10)();
+      expect(rule.validate(0)).toBe(false);
+      expect(rule.validate(11)).toBe(false);
+    });
+
+    test('should have correct message', () => {
+      const rule = IsBetween(1, 100)();
+      expect(rule.message).toBe('必须在 1 和 100 之间');
+    });
+  });
+
+  describe('Contains', () => {
+    test('should pass when string contains substring', () => {
+      const rule = Contains('hello')();
+      expect(rule.validate('hello world')).toBe(true);
+      expect(rule.validate('say hello')).toBe(true);
+    });
+
+    test('should fail when string does not contain substring', () => {
+      const rule = Contains('hello')();
+      expect(rule.validate('hi world')).toBe(false);
+    });
+
+    test('should have correct message', () => {
+      const rule = Contains('test')();
+      expect(rule.message).toBe('必须包含 "test"');
+    });
+  });
+
+  describe('NotContains', () => {
+    test('should pass when string does not contain substring', () => {
+      const rule = NotContains('bad')();
+      expect(rule.validate('good word')).toBe(true);
+    });
+
+    test('should fail when string contains substring', () => {
+      const rule = NotContains('bad')();
+      expect(rule.validate('bad word')).toBe(false);
+    });
+
+    test('should have correct message', () => {
+      const rule = NotContains('spam')();
+      expect(rule.message).toBe('不能包含 "spam"');
+    });
+  });
+});