hash_validator 1.2.0 → 2.0.1

data/spec/validators/hash_validator_spec.rb

@@ -1,6 +1,8 @@
-require 'spec_helper'
+# frozen_string_literal: true
 
-describe 'ActionController::Parameters support' do
+require "spec_helper"
+
+describe "ActionController::Parameters support" do
   # Mock ActionController::Parameters for testing
   let(:mock_params_class) do
     Class.new do
@@ -23,12 +25,12 @@ describe 'ActionController::Parameters support' do
       end
 
       def is_a?(klass)
-        return true if klass.name == 'ActionController::Parameters'
+        return true if klass.name == "ActionController::Parameters"
         super
       end
 
       def class
-        OpenStruct.new(name: 'ActionController::Parameters')
+        Struct.new(:name).new("ActionController::Parameters")
       end
     end
   end
@@ -41,62 +43,62 @@ describe 'ActionController::Parameters support' do
     end
   end
 
-  it 'should validate ActionController::Parameters objects' do
-    params = ActionController::Parameters.new({ name: 'John', age: 30 })
-    validations = { name: 'string', age: 'integer' }
-    
+  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', 
+  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' }
+
+    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
+  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'
+      name: "John",
+      email: "john@example.com",
+      website: "https://john.com",
+      zip_code: "12345"
     })
-    
+
     validations = {
-      name: 'alpha',
-      email: 'email',
-      website: 'url',
-      zip_code: 'digits'
+      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' }
-    
+  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
+end

data/spec/validators/hex_color_validator_spec.rb

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

data/spec/validators/in_enumerable_spec.rb

@@ -1,67 +1,69 @@
-require 'spec_helper'
+# frozen_string_literal: true
 
-describe 'Enumerable validator' do
-  describe 'Accepting Enumerables in validations' do
-    it 'should accept an empty array' do
+require "spec_helper"
+
+describe "Enumerable validator" do
+  describe "Accepting Enumerables in validations" do
+    it "should accept an empty array" do
       validate({}, { foo: [] })
     end
 
-    it 'should accept an array' do
-      validate({}, { foo: [ 'apple', 'banana', 'carrot' ] })
+    it "should accept an array" do
+      validate({}, { foo: [ "apple", "banana", "carrot" ] })
     end
 
-    it 'should accept a hash' do
-      validate({}, { foo: { apple: 'apple', banana: 'banana', carrot: 'cattot' } })
+    it "should accept a hash" do
+      validate({}, { foo: { apple: "apple", banana: "banana", carrot: "cattot" } })
     end
   end
 
-  describe '#validate' do
-    describe 'Simple Array' do
-      let(:validations) {{ fruit: [ 'apple', 'banana', 'carrot' ] }}
+  describe "#validate" do
+    describe "Simple Array" do
+      let(:validations) { { fruit: [ "apple", "banana", "carrot" ] } }
 
-      it 'should validate true if the value is present' do
-        expect(validate({ fruit: 'apple' }, validations).valid?).to eq true
+      it "should validate true if the value is present" do
+        expect(validate({ fruit: "apple" }, validations).valid?).to eq true
       end
 
-      it 'should validate false if the value is not present' do
-        expect(validate({ fruit: 'pear' }, validations).valid?).to eq false
+      it "should validate false if the value is not present" do
+        expect(validate({ fruit: "pear" }, validations).valid?).to eq false
       end
 
-      it 'should validate false if the key is not present' do
-        expect(validate({ something: 'apple' }, validations).valid?).to eq false
+      it "should validate false if the key is not present" do
+        expect(validate({ something: "apple" }, validations).valid?).to eq false
       end
 
-      it 'should provide an appropriate error message is the value is not present' do
-        expect(validate({ fruit: 'pear' }, validations).errors).to eq({ fruit: 'value from list required' })
+      it "should provide an appropriate error message is the value is not present" do
+        expect(validate({ fruit: "pear" }, validations).errors).to eq({ fruit: "value from list required" })
       end
     end
 
-    describe 'Range' do
-      let(:validations) {{ number: 1..10 }}
+    describe "Range" do
+      let(:validations) { { number: 1..10 } }
 
-      it 'should validate true if the value is present' do
+      it "should validate true if the value is present" do
         expect(validate({ number: 5 }, validations).valid?).to eq true
       end
-      it 'should validate false if the value is not present' do
+      it "should validate false if the value is not present" do
         expect(validate({ number: 15 }, validations).valid?).to eq false
       end
     end
 
-    describe 'Infinite Range' do
-      let(:validations) {{ number: 1..Float::INFINITY }}
+    describe "Infinite Range" do
+      let(:validations) { { number: 1..Float::INFINITY } }
 
-      it 'should validate true if the value is present' do
+      it "should validate true if the value is present" do
         expect(validate({ number: 5 }, validations).valid?).to eq true
       end
-      it 'should validate false if the value is not present' do
+      it "should validate false if the value is not present" do
         expect(validate({ number: -5 }, validations).valid?).to eq false
       end
     end
 
-    describe 'nil values' do
-      let(:validations) {{ fruit: [ nil, :apple, :banana ] }}
+    describe "nil values" do
+      let(:validations) { { fruit: [ nil, :apple, :banana ] } }
 
-      it 'should validate true if a nil value is present' do
+      it "should validate true if a nil value is present" do
         expect(validate({ fruit: nil }, validations).valid?).to eq true
       end
     end

data/spec/validators/ip_validator_spec.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+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,101 @@
+# frozen_string_literal: true
+
+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