hash_validator 1.1.1 → 2.0.0

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/hash_validator_spec.rb

@@ -0,0 +1,102 @@
+require 'spec_helper'
+
+describe 'ActionController::Parameters support' do
+  # Mock ActionController::Parameters for testing
+  let(:mock_params_class) do
+    Class.new do
+      attr_reader :data
+
+      def initialize(data)
+        @data = data
+      end
+
+      def [](key)
+        @data[key]
+      end
+
+      def keys
+        @data.keys
+      end
+
+      def to_unsafe_h
+        @data
+      end
+
+      def is_a?(klass)
+        return true if klass.name == 'ActionController::Parameters'
+        super
+      end
+
+      def class
+        OpenStruct.new(name: 'ActionController::Parameters')
+      end
+    end
+  end
+
+  before do
+    # Define ActionController::Parameters constant for testing
+    unless defined?(ActionController::Parameters)
+      ActionController = Module.new unless defined?(ActionController)
+      ActionController.const_set(:Parameters, mock_params_class)
+    end
+  end
+
+  it 'should validate ActionController::Parameters objects' do
+    params = ActionController::Parameters.new({ name: 'John', age: 30 })
+    validations = { name: 'string', age: 'integer' }
+    
+    validator = HashValidator.validate(params, validations)
+    
+    expect(validator.valid?).to be true
+    expect(validator.errors).to be_empty
+  end
+
+  it 'should handle nested ActionController::Parameters' do
+    nested_params = ActionController::Parameters.new({ theme: 'dark' })
+    params = ActionController::Parameters.new({ 
+      name: 'John', 
+      preferences: nested_params
+    })
+    
+    validations = { 
+      name: 'string',
+      preferences: { theme: 'string' }
+    }
+    
+    validator = HashValidator.validate(params, validations)
+    
+    expect(validator.valid?).to be true
+    expect(validator.errors).to be_empty
+  end
+
+  it 'should validate ActionController::Parameters with our new validators' do
+    params = ActionController::Parameters.new({
+      name: 'John',
+      email: 'john@example.com',
+      website: 'https://john.com',
+      zip_code: '12345'
+    })
+    
+    validations = {
+      name: 'alpha',
+      email: 'email',
+      website: 'url',
+      zip_code: 'digits'
+    }
+    
+    validator = HashValidator.validate(params, validations)
+    
+    expect(validator.valid?).to be true
+    expect(validator.errors).to be_empty
+  end
+
+  it 'should still work with regular hashes' do
+    hash = { name: 'John', age: 30 }
+    validations = { name: 'string', age: 'integer' }
+    
+    validator = HashValidator.validate(hash, validations)
+    
+    expect(validator.valid?).to be true
+    expect(validator.errors).to be_empty
+  end
+end

data/spec/validators/hex_color_validator_spec.rb

@@ -0,0 +1,111 @@
+require 'spec_helper'
+
+describe HashValidator::Validator::HexColorValidator do
+  let(:validator) { HashValidator::Validator::HexColorValidator.new }
+
+  context 'valid hex colors' do
+    it 'validates 6-digit hex colors (lowercase)' do
+      errors = {}
+      validator.validate('key', '#ff0000', {}, errors)
+      expect(errors).to be_empty
+    end
+
+    it 'validates 6-digit hex colors (uppercase)' do
+      errors = {}
+      validator.validate('key', '#FF0000', {}, errors)
+      expect(errors).to be_empty
+    end
+
+    it 'validates 6-digit hex colors (mixed case)' do
+      errors = {}
+      validator.validate('key', '#Ff0000', {}, errors)
+      expect(errors).to be_empty
+    end
+
+    it 'validates 3-digit hex colors (lowercase)' do
+      errors = {}
+      validator.validate('key', '#f00', {}, errors)
+      expect(errors).to be_empty
+    end
+
+    it 'validates 3-digit hex colors (uppercase)' do
+      errors = {}
+      validator.validate('key', '#F00', {}, errors)
+      expect(errors).to be_empty
+    end
+
+    it 'validates black color' do
+      errors = {}
+      validator.validate('key', '#000000', {}, errors)
+      expect(errors).to be_empty
+    end
+
+    it 'validates white color' do
+      errors = {}
+      validator.validate('key', '#ffffff', {}, errors)
+      expect(errors).to be_empty
+    end
+
+    it 'validates complex hex colors' do
+      errors = {}
+      validator.validate('key', '#3a7bd4', {}, errors)
+      expect(errors).to be_empty
+    end
+  end
+
+  context 'invalid hex colors' do
+    it 'rejects non-string values' do
+      errors = {}
+      validator.validate('key', 123, {}, errors)
+      expect(errors['key']).to eq('is not a valid hex color')
+    end
+
+    it 'rejects nil values' do
+      errors = {}
+      validator.validate('key', nil, {}, errors)
+      expect(errors['key']).to eq('is not a valid hex color')
+    end
+
+    it 'rejects hex colors without hash' do
+      errors = {}
+      validator.validate('key', 'ff0000', {}, errors)
+      expect(errors['key']).to eq('is not a valid hex color')
+    end
+
+    it 'rejects invalid length (4 digits)' do
+      errors = {}
+      validator.validate('key', '#ff00', {}, errors)
+      expect(errors['key']).to eq('is not a valid hex color')
+    end
+
+    it 'rejects invalid length (5 digits)' do
+      errors = {}
+      validator.validate('key', '#ff000', {}, errors)
+      expect(errors['key']).to eq('is not a valid hex color')
+    end
+
+    it 'rejects invalid length (7 digits)' do
+      errors = {}
+      validator.validate('key', '#ff00000', {}, errors)
+      expect(errors['key']).to eq('is not a valid hex color')
+    end
+
+    it 'rejects invalid characters' do
+      errors = {}
+      validator.validate('key', '#gg0000', {}, errors)
+      expect(errors['key']).to eq('is not a valid hex color')
+    end
+
+    it 'rejects empty strings' do
+      errors = {}
+      validator.validate('key', '', {}, errors)
+      expect(errors['key']).to eq('is not a valid hex color')
+    end
+
+    it 'rejects just hash symbol' do
+      errors = {}
+      validator.validate('key', '#', {}, errors)
+      expect(errors['key']).to eq('is not a valid hex color')
+    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