hash_validator 1.2.0 → 2.0.0

data/spec/validators/dynamic_func_validator_spec.rb

@@ -0,0 +1,252 @@
+require 'spec_helper'
+
+describe HashValidator::Validator::DynamicFuncValidator do
+  describe 'Function-based validator' do
+    let(:odd_func_validator) do
+      HashValidator::Validator::DynamicFuncValidator.new(
+        'odd_func',
+        ->(n) { n.is_a?(Integer) && n.odd? },
+        'is not an odd integer'
+      )
+    end
+
+    let(:range_validator) do
+      HashValidator::Validator::DynamicFuncValidator.new(
+        'in_range',
+        ->(n) { n.is_a?(Numeric) && n >= 18 && n <= 65 },
+        'must be between 18 and 65'
+      )
+    end
+
+    let(:custom_validator) do
+      HashValidator::Validator::DynamicFuncValidator.new(
+        'custom',
+        proc { |v| v.to_s.length > 5 },
+        'must be longer than 5 characters'
+      )
+    end
+
+    let(:errors) { Hash.new }
+
+    describe '#initialize' do
+      it 'requires a callable object' do
+        expect {
+          HashValidator::Validator::DynamicFuncValidator.new('test', 'not_callable')
+        }.to raise_error(ArgumentError, 'Function must be callable (proc or lambda)')
+      end
+
+      it 'accepts a lambda' do
+        validator = HashValidator::Validator::DynamicFuncValidator.new(
+          'test',
+          ->(v) { true }
+        )
+        expect(validator.func).to respond_to(:call)
+      end
+
+      it 'accepts a proc' do
+        validator = HashValidator::Validator::DynamicFuncValidator.new(
+          'test',
+          proc { |v| true }
+        )
+        expect(validator.func).to respond_to(:call)
+      end
+
+      it 'accepts a custom error message' do
+        validator = HashValidator::Validator::DynamicFuncValidator.new(
+          'test',
+          ->(v) { true },
+          'custom error'
+        )
+        expect(validator.error_message).to eq('custom error')
+      end
+
+      it 'uses default error message when none provided' do
+        validator = HashValidator::Validator::DynamicFuncValidator.new(
+          'test',
+          ->(v) { true }
+        )
+        expect(validator.error_message).to eq('test required')
+      end
+    end
+
+    describe '#should_validate?' do
+      it 'validates the correct name' do
+        expect(odd_func_validator.should_validate?('odd_func')).to eq true
+      end
+
+      it 'does not validate other names' do
+        expect(odd_func_validator.should_validate?('even_func')).to eq false
+        expect(odd_func_validator.should_validate?('string')).to eq false
+      end
+    end
+
+    describe '#validate' do
+      context 'with odd number function' do
+        it 'validates odd integers correctly' do
+          odd_func_validator.validate(:key, 1, {}, errors)
+          expect(errors).to be_empty
+
+          errors.clear
+          odd_func_validator.validate(:key, 13, {}, errors)
+          expect(errors).to be_empty
+
+          errors.clear
+          odd_func_validator.validate(:key, -7, {}, errors)
+          expect(errors).to be_empty
+        end
+
+        it 'rejects even integers' do
+          odd_func_validator.validate(:key, 2, {}, errors)
+          expect(errors).to eq({ key: 'is not an odd integer' })
+
+          errors.clear
+          odd_func_validator.validate(:key, 100, {}, errors)
+          expect(errors).to eq({ key: 'is not an odd integer' })
+        end
+
+        it 'rejects non-integers' do
+          odd_func_validator.validate(:key, 1.5, {}, errors)
+          expect(errors).to eq({ key: 'is not an odd integer' })
+
+          errors.clear
+          odd_func_validator.validate(:key, '1', {}, errors)
+          expect(errors).to eq({ key: 'is not an odd integer' })
+        end
+      end
+
+      context 'with range validator' do
+        it 'validates numbers in range' do
+          range_validator.validate(:key, 18, {}, errors)
+          expect(errors).to be_empty
+
+          errors.clear
+          range_validator.validate(:key, 30, {}, errors)
+          expect(errors).to be_empty
+
+          errors.clear
+          range_validator.validate(:key, 65, {}, errors)
+          expect(errors).to be_empty
+
+          errors.clear
+          range_validator.validate(:key, 25.5, {}, errors)
+          expect(errors).to be_empty
+        end
+
+        it 'rejects numbers outside range' do
+          range_validator.validate(:key, 17, {}, errors)
+          expect(errors).to eq({ key: 'must be between 18 and 65' })
+
+          errors.clear
+          range_validator.validate(:key, 66, {}, errors)
+          expect(errors).to eq({ key: 'must be between 18 and 65' })
+
+          errors.clear
+          range_validator.validate(:key, -5, {}, errors)
+          expect(errors).to eq({ key: 'must be between 18 and 65' })
+        end
+
+        it 'rejects non-numeric values' do
+          range_validator.validate(:key, 'twenty', {}, errors)
+          expect(errors).to eq({ key: 'must be between 18 and 65' })
+        end
+      end
+
+      context 'with custom validator using proc' do
+        it 'validates strings longer than 5 chars' do
+          custom_validator.validate(:key, 'hello world', {}, errors)
+          expect(errors).to be_empty
+
+          errors.clear
+          custom_validator.validate(:key, 'testing', {}, errors)
+          expect(errors).to be_empty
+        end
+
+        it 'rejects strings 5 chars or shorter' do
+          custom_validator.validate(:key, 'hello', {}, errors)
+          expect(errors).to eq({ key: 'must be longer than 5 characters' })
+
+          errors.clear
+          custom_validator.validate(:key, 'hi', {}, errors)
+          expect(errors).to eq({ key: 'must be longer than 5 characters' })
+        end
+
+        it 'converts values to strings' do
+          custom_validator.validate(:key, 123456, {}, errors)
+          expect(errors).to be_empty
+
+          errors.clear
+          custom_validator.validate(:key, 12345, {}, errors)
+          expect(errors).to eq({ key: 'must be longer than 5 characters' })
+        end
+      end
+
+      context 'with function that raises errors' do
+        let(:error_func_validator) do
+          HashValidator::Validator::DynamicFuncValidator.new(
+            'error_func',
+            ->(v) { raise 'intentional error' },
+            'validation failed'
+          )
+        end
+
+        it 'treats exceptions as validation failures' do
+          error_func_validator.validate(:key, 'any value', {}, errors)
+          expect(errors).to eq({ key: 'validation failed' })
+        end
+      end
+    end
+
+    describe 'Integration with HashValidator.add_validator' do
+      before do
+        HashValidator.add_validator('adult_age', 
+          func: ->(age) { age.is_a?(Integer) && age >= 18 }, 
+          error_message: 'must be 18 or older')
+        
+        HashValidator.add_validator('palindrome',
+          func: proc { |s| s.to_s == s.to_s.reverse },
+          error_message: 'must be a palindrome')
+      end
+
+      after do
+        HashValidator.remove_validator('adult_age')
+        HashValidator.remove_validator('palindrome')
+      end
+
+      it 'can register lambda-based validators' do
+        validator = HashValidator.validate(
+          { age: 25 },
+          { age: 'adult_age' }
+        )
+        expect(validator.valid?).to eq true
+        expect(validator.errors).to be_empty
+      end
+
+      it 'returns errors for invalid lambda validations' do
+        validator = HashValidator.validate(
+          { age: 16 },
+          { age: 'adult_age' }
+        )
+        expect(validator.valid?).to eq false
+        expect(validator.errors).to eq({ age: 'must be 18 or older' })
+      end
+
+      it 'can register proc-based validators' do
+        validator = HashValidator.validate(
+          { word: 'racecar' },
+          { word: 'palindrome' }
+        )
+        expect(validator.valid?).to eq true
+        expect(validator.errors).to be_empty
+      end
+
+      it 'returns errors for invalid proc validations' do
+        validator = HashValidator.validate(
+          { word: 'hello' },
+          { word: 'palindrome' }
+        )
+        expect(validator.valid?).to eq false
+        expect(validator.errors).to eq({ word: 'must be a palindrome' })
+      end
+    end
+  end
+end

data/spec/validators/dynamic_pattern_validator_spec.rb

@@ -0,0 +1,150 @@
+require 'spec_helper'
+
+describe HashValidator::Validator::DynamicPatternValidator do
+  describe 'Pattern-based validator' do
+    let(:odd_pattern_validator) do
+      HashValidator::Validator::DynamicPatternValidator.new(
+        'odd_pattern',
+        /\A\d*[13579]\z/,
+        'is not an odd number'
+      )
+    end
+
+    let(:postal_code_validator) do
+      HashValidator::Validator::DynamicPatternValidator.new(
+        'us_postal',
+        /\A\d{5}(-\d{4})?\z/,
+        'is not a valid US postal code'
+      )
+    end
+
+    let(:errors) { Hash.new }
+
+    describe '#initialize' do
+      it 'requires a valid regular expression' do
+        expect {
+          HashValidator::Validator::DynamicPatternValidator.new('test', 'not_a_regex')
+        }.to raise_error(ArgumentError, 'Pattern must be a regular expression')
+      end
+
+      it 'accepts a custom error message' do
+        validator = HashValidator::Validator::DynamicPatternValidator.new(
+          'test',
+          /test/,
+          'custom error'
+        )
+        expect(validator.error_message).to eq('custom error')
+      end
+
+      it 'uses default error message when none provided' do
+        validator = HashValidator::Validator::DynamicPatternValidator.new('test', /test/)
+        expect(validator.error_message).to eq('test required')
+      end
+    end
+
+    describe '#should_validate?' do
+      it 'validates the correct name' do
+        expect(odd_pattern_validator.should_validate?('odd_pattern')).to eq true
+      end
+
+      it 'does not validate other names' do
+        expect(odd_pattern_validator.should_validate?('even_pattern')).to eq false
+        expect(odd_pattern_validator.should_validate?('string')).to eq false
+      end
+    end
+
+    describe '#validate' do
+      context 'with odd number pattern' do
+        it 'validates odd numbers correctly' do
+          odd_pattern_validator.validate(:key, '1', {}, errors)
+          expect(errors).to be_empty
+
+          errors.clear
+          odd_pattern_validator.validate(:key, '13', {}, errors)
+          expect(errors).to be_empty
+
+          errors.clear
+          odd_pattern_validator.validate(:key, '999', {}, errors)
+          expect(errors).to be_empty
+        end
+
+        it 'rejects even numbers' do
+          odd_pattern_validator.validate(:key, '2', {}, errors)
+          expect(errors).to eq({ key: 'is not an odd number' })
+
+          errors.clear
+          odd_pattern_validator.validate(:key, '100', {}, errors)
+          expect(errors).to eq({ key: 'is not an odd number' })
+        end
+
+        it 'rejects non-numeric strings' do
+          odd_pattern_validator.validate(:key, 'abc', {}, errors)
+          expect(errors).to eq({ key: 'is not an odd number' })
+        end
+
+        it 'converts non-string values to strings' do
+          odd_pattern_validator.validate(:key, 13, {}, errors)
+          expect(errors).to be_empty
+
+          errors.clear
+          odd_pattern_validator.validate(:key, 14, {}, errors)
+          expect(errors).to eq({ key: 'is not an odd number' })
+        end
+      end
+
+      context 'with postal code pattern' do
+        it 'validates correct postal codes' do
+          postal_code_validator.validate(:key, '12345', {}, errors)
+          expect(errors).to be_empty
+
+          errors.clear
+          postal_code_validator.validate(:key, '12345-6789', {}, errors)
+          expect(errors).to be_empty
+        end
+
+        it 'rejects invalid postal codes' do
+          postal_code_validator.validate(:key, '1234', {}, errors)
+          expect(errors).to eq({ key: 'is not a valid US postal code' })
+
+          errors.clear
+          postal_code_validator.validate(:key, '12345-678', {}, errors)
+          expect(errors).to eq({ key: 'is not a valid US postal code' })
+
+          errors.clear
+          postal_code_validator.validate(:key, 'ABCDE', {}, errors)
+          expect(errors).to eq({ key: 'is not a valid US postal code' })
+        end
+      end
+    end
+
+    describe 'Integration with HashValidator.add_validator' do
+      before do
+        HashValidator.add_validator('phone_number', 
+          pattern: /\A\d{3}-\d{3}-\d{4}\z/, 
+          error_message: 'is not a valid phone number')
+      end
+
+      after do
+        HashValidator.remove_validator('phone_number')
+      end
+
+      it 'can be registered and used via add_validator' do
+        validator = HashValidator.validate(
+          { phone: '555-123-4567' },
+          { phone: 'phone_number' }
+        )
+        expect(validator.valid?).to eq true
+        expect(validator.errors).to be_empty
+      end
+
+      it 'returns errors for invalid values' do
+        validator = HashValidator.validate(
+          { phone: '5551234567' },
+          { phone: 'phone_number' }
+        )
+        expect(validator.valid?).to eq false
+        expect(validator.errors).to eq({ phone: 'is not a valid phone number' })
+      end
+    end
+  end
+end

data/spec/validators/ip_validator_spec.rb

@@ -0,0 +1,105 @@
+require 'spec_helper'
+
+describe HashValidator::Validator::IpValidator do
+  let(:validator) { HashValidator::Validator::IpValidator.new }
+
+  context 'valid IP addresses' do
+    it 'validates IPv4 addresses' do
+      errors = {}
+      validator.validate('key', '192.168.1.1', {}, errors)
+      expect(errors).to be_empty
+    end
+
+    it 'validates IPv4 localhost' do
+      errors = {}
+      validator.validate('key', '127.0.0.1', {}, errors)
+      expect(errors).to be_empty
+    end
+
+    it 'validates IPv4 zero address' do
+      errors = {}
+      validator.validate('key', '0.0.0.0', {}, errors)
+      expect(errors).to be_empty
+    end
+
+    it 'validates IPv4 broadcast address' do
+      errors = {}
+      validator.validate('key', '255.255.255.255', {}, errors)
+      expect(errors).to be_empty
+    end
+
+    it 'validates IPv6 addresses' do
+      errors = {}
+      validator.validate('key', '2001:db8:85a3::8a2e:370:7334', {}, errors)
+      expect(errors).to be_empty
+    end
+
+    it 'validates IPv6 localhost' do
+      errors = {}
+      validator.validate('key', '::1', {}, errors)
+      expect(errors).to be_empty
+    end
+
+    it 'validates IPv6 zero address' do
+      errors = {}
+      validator.validate('key', '::', {}, errors)
+      expect(errors).to be_empty
+    end
+
+    it 'validates IPv4-mapped IPv6 addresses' do
+      errors = {}
+      validator.validate('key', '::ffff:192.168.1.1', {}, errors)
+      expect(errors).to be_empty
+    end
+  end
+
+  context 'invalid IP addresses' do
+    it 'rejects non-string values' do
+      errors = {}
+      validator.validate('key', 123, {}, errors)
+      expect(errors['key']).to eq('is not a valid IP address')
+    end
+
+    it 'rejects nil values' do
+      errors = {}
+      validator.validate('key', nil, {}, errors)
+      expect(errors['key']).to eq('is not a valid IP address')
+    end
+
+    it 'rejects malformed IPv4 addresses' do
+      errors = {}
+      validator.validate('key', '256.1.1.1', {}, errors)
+      expect(errors['key']).to eq('is not a valid IP address')
+    end
+
+    it 'rejects malformed IPv6 addresses' do
+      errors = {}
+      validator.validate('key', '2001:db8:85a3::8a2e::7334', {}, errors)
+      expect(errors['key']).to eq('is not a valid IP address')
+    end
+
+    it 'rejects non-IP strings' do
+      errors = {}
+      validator.validate('key', 'not an ip', {}, errors)
+      expect(errors['key']).to eq('is not a valid IP address')
+    end
+
+    it 'rejects empty strings' do
+      errors = {}
+      validator.validate('key', '', {}, errors)
+      expect(errors['key']).to eq('is not a valid IP address')
+    end
+
+    it 'rejects hostnames' do
+      errors = {}
+      validator.validate('key', 'example.com', {}, errors)
+      expect(errors['key']).to eq('is not a valid IP address')
+    end
+
+    it 'rejects URLs' do
+      errors = {}
+      validator.validate('key', 'http://192.168.1.1', {}, errors)
+      expect(errors['key']).to eq('is not a valid IP address')
+    end
+  end
+end

data/spec/validators/ipv4_validator_spec.rb

@@ -0,0 +1,99 @@
+require 'spec_helper'
+
+describe HashValidator::Validator::Ipv4Validator do
+  let(:validator) { HashValidator::Validator::Ipv4Validator.new }
+
+  context 'valid IPv4 addresses' do
+    it 'validates standard IPv4 addresses' do
+      errors = {}
+      validator.validate('key', '192.168.1.1', {}, errors)
+      expect(errors).to be_empty
+    end
+
+    it 'validates localhost' do
+      errors = {}
+      validator.validate('key', '127.0.0.1', {}, errors)
+      expect(errors).to be_empty
+    end
+
+    it 'validates zero address' do
+      errors = {}
+      validator.validate('key', '0.0.0.0', {}, errors)
+      expect(errors).to be_empty
+    end
+
+    it 'validates broadcast address' do
+      errors = {}
+      validator.validate('key', '255.255.255.255', {}, errors)
+      expect(errors).to be_empty
+    end
+
+    it 'validates private network addresses' do
+      errors = {}
+      validator.validate('key', '10.0.0.1', {}, errors)
+      expect(errors).to be_empty
+    end
+
+    it 'validates Class B private addresses' do
+      errors = {}
+      validator.validate('key', '172.16.0.1', {}, errors)
+      expect(errors).to be_empty
+    end
+  end
+
+  context 'invalid IPv4 addresses' do
+    it 'rejects non-string values' do
+      errors = {}
+      validator.validate('key', 123, {}, errors)
+      expect(errors['key']).to eq('is not a valid IPv4 address')
+    end
+
+    it 'rejects nil values' do
+      errors = {}
+      validator.validate('key', nil, {}, errors)
+      expect(errors['key']).to eq('is not a valid IPv4 address')
+    end
+
+    it 'rejects octets over 255' do
+      errors = {}
+      validator.validate('key', '256.1.1.1', {}, errors)
+      expect(errors['key']).to eq('is not a valid IPv4 address')
+    end
+
+    it 'rejects too few octets' do
+      errors = {}
+      validator.validate('key', '192.168.1', {}, errors)
+      expect(errors['key']).to eq('is not a valid IPv4 address')
+    end
+
+    it 'rejects too many octets' do
+      errors = {}
+      validator.validate('key', '192.168.1.1.1', {}, errors)
+      expect(errors['key']).to eq('is not a valid IPv4 address')
+    end
+
+    it 'rejects IPv6 addresses' do
+      errors = {}
+      validator.validate('key', '2001:db8::1', {}, errors)
+      expect(errors['key']).to eq('is not a valid IPv4 address')
+    end
+
+    it 'rejects malformed addresses' do
+      errors = {}
+      validator.validate('key', '192.168.1.', {}, errors)
+      expect(errors['key']).to eq('is not a valid IPv4 address')
+    end
+
+    it 'rejects empty strings' do
+      errors = {}
+      validator.validate('key', '', {}, errors)
+      expect(errors['key']).to eq('is not a valid IPv4 address')
+    end
+
+    it 'rejects non-numeric octets' do
+      errors = {}
+      validator.validate('key', '192.168.a.1', {}, errors)
+      expect(errors['key']).to eq('is not a valid IPv4 address')
+    end
+  end
+end

data/spec/validators/ipv6_validator_spec.rb

@@ -0,0 +1,99 @@
+require 'spec_helper'
+
+describe HashValidator::Validator::Ipv6Validator do
+  let(:validator) { HashValidator::Validator::Ipv6Validator.new }
+
+  context 'valid IPv6 addresses' do
+    it 'validates full IPv6 addresses' do
+      errors = {}
+      validator.validate('key', '2001:0db8:85a3:0000:0000:8a2e:0370:7334', {}, errors)
+      expect(errors).to be_empty
+    end
+
+    it 'validates compressed IPv6 addresses' do
+      errors = {}
+      validator.validate('key', '2001:db8:85a3::8a2e:370:7334', {}, errors)
+      expect(errors).to be_empty
+    end
+
+    it 'validates IPv6 localhost' do
+      errors = {}
+      validator.validate('key', '::1', {}, errors)
+      expect(errors).to be_empty
+    end
+
+    it 'validates IPv6 zero address' do
+      errors = {}
+      validator.validate('key', '::', {}, errors)
+      expect(errors).to be_empty
+    end
+
+    it 'validates IPv6 with leading zeros' do
+      errors = {}
+      validator.validate('key', '2001:0db8::0001', {}, errors)
+      expect(errors).to be_empty
+    end
+
+    it 'validates IPv6 with mixed case' do
+      errors = {}
+      validator.validate('key', '2001:DB8::1', {}, errors)
+      expect(errors).to be_empty
+    end
+
+    it 'validates IPv4-mapped IPv6 addresses' do
+      errors = {}
+      validator.validate('key', '::ffff:192.168.1.1', {}, errors)
+      expect(errors).to be_empty
+    end
+  end
+
+  context 'invalid IPv6 addresses' do
+    it 'rejects non-string values' do
+      errors = {}
+      validator.validate('key', 123, {}, errors)
+      expect(errors['key']).to eq('is not a valid IPv6 address')
+    end
+
+    it 'rejects nil values' do
+      errors = {}
+      validator.validate('key', nil, {}, errors)
+      expect(errors['key']).to eq('is not a valid IPv6 address')
+    end
+
+    it 'rejects IPv4 addresses' do
+      errors = {}
+      validator.validate('key', '192.168.1.1', {}, errors)
+      expect(errors['key']).to eq('is not a valid IPv6 address')
+    end
+
+    it 'rejects malformed IPv6 addresses' do
+      errors = {}
+      validator.validate('key', '2001:db8:85a3::8a2e::7334', {}, errors)
+      expect(errors['key']).to eq('is not a valid IPv6 address')
+    end
+
+    it 'rejects too many groups' do
+      errors = {}
+      validator.validate('key', '2001:0db8:85a3:0000:0000:8a2e:0370:7334:extra', {}, errors)
+      expect(errors['key']).to eq('is not a valid IPv6 address')
+    end
+
+    it 'rejects invalid characters' do
+      errors = {}
+      validator.validate('key', '2001:db8:85a3::8a2g:370:7334', {}, errors)
+      expect(errors['key']).to eq('is not a valid IPv6 address')
+    end
+
+    it 'rejects empty strings' do
+      errors = {}
+      validator.validate('key', '', {}, errors)
+      expect(errors['key']).to eq('is not a valid IPv6 address')
+    end
+
+    it 'rejects incomplete addresses' do
+      errors = {}
+      validator.validate('key', '2001:db8:', {}, errors)
+      expect(errors['key']).to eq('is not a valid IPv6 address')
+    end
+  end
+end