hash_validator 2.0.0 → 2.0.1

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

@@ -1,105 +1,107 @@
-require 'spec_helper'
+# 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
+  context "valid IP addresses" do
+    it "validates IPv4 addresses" do
       errors = {}
-      validator.validate('key', '192.168.1.1', {}, errors)
+      validator.validate("key", "192.168.1.1", {}, errors)
       expect(errors).to be_empty
     end
 
-    it 'validates IPv4 localhost' do
+    it "validates IPv4 localhost" do
       errors = {}
-      validator.validate('key', '127.0.0.1', {}, errors)
+      validator.validate("key", "127.0.0.1", {}, errors)
       expect(errors).to be_empty
     end
 
-    it 'validates IPv4 zero address' do
+    it "validates IPv4 zero address" do
       errors = {}
-      validator.validate('key', '0.0.0.0', {}, errors)
+      validator.validate("key", "0.0.0.0", {}, errors)
       expect(errors).to be_empty
     end
 
-    it 'validates IPv4 broadcast address' do
+    it "validates IPv4 broadcast address" do
       errors = {}
-      validator.validate('key', '255.255.255.255', {}, errors)
+      validator.validate("key", "255.255.255.255", {}, errors)
       expect(errors).to be_empty
     end
 
-    it 'validates IPv6 addresses' do
+    it "validates IPv6 addresses" do
       errors = {}
-      validator.validate('key', '2001:db8:85a3::8a2e:370:7334', {}, errors)
+      validator.validate("key", "2001:db8:85a3::8a2e:370:7334", {}, errors)
       expect(errors).to be_empty
     end
 
-    it 'validates IPv6 localhost' do
+    it "validates IPv6 localhost" do
       errors = {}
-      validator.validate('key', '::1', {}, errors)
+      validator.validate("key", "::1", {}, errors)
       expect(errors).to be_empty
     end
 
-    it 'validates IPv6 zero address' do
+    it "validates IPv6 zero address" do
       errors = {}
-      validator.validate('key', '::', {}, errors)
+      validator.validate("key", "::", {}, errors)
       expect(errors).to be_empty
     end
 
-    it 'validates IPv4-mapped IPv6 addresses' do
+    it "validates IPv4-mapped IPv6 addresses" do
       errors = {}
-      validator.validate('key', '::ffff:192.168.1.1', {}, 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
+  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')
+      validator.validate("key", 123, {}, errors)
+      expect(errors["key"]).to eq("is not a valid IP address")
     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 IP address')
+      validator.validate("key", nil, {}, errors)
+      expect(errors["key"]).to eq("is not a valid IP address")
     end
 
-    it 'rejects malformed IPv4 addresses' do
+    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')
+      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
+    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')
+      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
+    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')
+      validator.validate("key", "not an ip", {}, errors)
+      expect(errors["key"]).to eq("is not a valid IP address")
     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 IP address')
+      validator.validate("key", "", {}, errors)
+      expect(errors["key"]).to eq("is not a valid IP address")
     end
 
-    it 'rejects hostnames' do
+    it "rejects hostnames" do
       errors = {}
-      validator.validate('key', 'example.com', {}, errors)
-      expect(errors['key']).to eq('is not a valid IP address')
+      validator.validate("key", "example.com", {}, errors)
+      expect(errors["key"]).to eq("is not a valid IP address")
     end
 
-    it 'rejects URLs' do
+    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')
+      validator.validate("key", "http://192.168.1.1", {}, errors)
+      expect(errors["key"]).to eq("is not a valid IP address")
     end
   end
-end
+end

data/spec/validators/ipv4_validator_spec.rb

@@ -1,99 +1,101 @@
-require 'spec_helper'
+# 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
+  context "valid IPv4 addresses" do
+    it "validates standard IPv4 addresses" do
       errors = {}
-      validator.validate('key', '192.168.1.1', {}, errors)
+      validator.validate("key", "192.168.1.1", {}, errors)
       expect(errors).to be_empty
     end
 
-    it 'validates localhost' do
+    it "validates localhost" do
       errors = {}
-      validator.validate('key', '127.0.0.1', {}, errors)
+      validator.validate("key", "127.0.0.1", {}, errors)
       expect(errors).to be_empty
     end
 
-    it 'validates zero address' do
+    it "validates zero address" do
       errors = {}
-      validator.validate('key', '0.0.0.0', {}, errors)
+      validator.validate("key", "0.0.0.0", {}, errors)
       expect(errors).to be_empty
     end
 
-    it 'validates broadcast address' do
+    it "validates broadcast address" do
       errors = {}
-      validator.validate('key', '255.255.255.255', {}, errors)
+      validator.validate("key", "255.255.255.255", {}, errors)
       expect(errors).to be_empty
     end
 
-    it 'validates private network addresses' do
+    it "validates private network addresses" do
       errors = {}
-      validator.validate('key', '10.0.0.1', {}, errors)
+      validator.validate("key", "10.0.0.1", {}, errors)
       expect(errors).to be_empty
     end
 
-    it 'validates Class B private addresses' do
+    it "validates Class B private addresses" do
       errors = {}
-      validator.validate('key', '172.16.0.1', {}, 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
+  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')
+      validator.validate("key", 123, {}, errors)
+      expect(errors["key"]).to eq("is not a valid IPv4 address")
     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 IPv4 address')
+      validator.validate("key", nil, {}, errors)
+      expect(errors["key"]).to eq("is not a valid IPv4 address")
     end
 
-    it 'rejects octets over 255' do
+    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')
+      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
+    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')
+      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
+    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')
+      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
+    it "rejects IPv6 addresses" do
       errors = {}
-      validator.validate('key', '2001:db8::1', {}, errors)
-      expect(errors['key']).to eq('is not a valid IPv4 address')
+      validator.validate("key", "2001:db8::1", {}, errors)
+      expect(errors["key"]).to eq("is not a valid IPv4 address")
     end
 
-    it 'rejects malformed addresses' do
+    it "rejects malformed addresses" do
       errors = {}
-      validator.validate('key', '192.168.1.', {}, errors)
-      expect(errors['key']).to eq('is not a valid IPv4 address')
+      validator.validate("key", "192.168.1.", {}, errors)
+      expect(errors["key"]).to eq("is not a valid IPv4 address")
     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 IPv4 address')
+      validator.validate("key", "", {}, errors)
+      expect(errors["key"]).to eq("is not a valid IPv4 address")
     end
 
-    it 'rejects non-numeric octets' do
+    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')
+      validator.validate("key", "192.168.a.1", {}, errors)
+      expect(errors["key"]).to eq("is not a valid IPv4 address")
     end
   end
-end
+end

data/spec/validators/ipv6_validator_spec.rb

@@ -1,99 +1,101 @@
-require 'spec_helper'
+# frozen_string_literal: true
+
+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
+  context "valid IPv6 addresses" do
+    it "validates full IPv6 addresses" do
       errors = {}
-      validator.validate('key', '2001:0db8:85a3:0000:0000:8a2e:0370:7334', {}, 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
+    it "validates compressed IPv6 addresses" do
       errors = {}
-      validator.validate('key', '2001:db8:85a3::8a2e:370:7334', {}, errors)
+      validator.validate("key", "2001:db8:85a3::8a2e:370:7334", {}, errors)
       expect(errors).to be_empty
     end
 
-    it 'validates IPv6 localhost' do
+    it "validates IPv6 localhost" do
       errors = {}
-      validator.validate('key', '::1', {}, errors)
+      validator.validate("key", "::1", {}, errors)
       expect(errors).to be_empty
     end
 
-    it 'validates IPv6 zero address' do
+    it "validates IPv6 zero address" do
       errors = {}
-      validator.validate('key', '::', {}, errors)
+      validator.validate("key", "::", {}, errors)
       expect(errors).to be_empty
     end
 
-    it 'validates IPv6 with leading zeros' do
+    it "validates IPv6 with leading zeros" do
       errors = {}
-      validator.validate('key', '2001:0db8::0001', {}, errors)
+      validator.validate("key", "2001:0db8::0001", {}, errors)
       expect(errors).to be_empty
     end
 
-    it 'validates IPv6 with mixed case' do
+    it "validates IPv6 with mixed case" do
       errors = {}
-      validator.validate('key', '2001:DB8::1', {}, errors)
+      validator.validate("key", "2001:DB8::1", {}, errors)
       expect(errors).to be_empty
     end
 
-    it 'validates IPv4-mapped IPv6 addresses' do
+    it "validates IPv4-mapped IPv6 addresses" do
       errors = {}
-      validator.validate('key', '::ffff:192.168.1.1', {}, 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
+  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')
+      validator.validate("key", 123, {}, errors)
+      expect(errors["key"]).to eq("is not a valid IPv6 address")
     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 IPv6 address')
+      validator.validate("key", nil, {}, errors)
+      expect(errors["key"]).to eq("is not a valid IPv6 address")
     end
 
-    it 'rejects IPv4 addresses' do
+    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')
+      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
+    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')
+      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
+    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')
+      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
+    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')
+      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
+    it "rejects empty strings" do
       errors = {}
-      validator.validate('key', '', {}, errors)
-      expect(errors['key']).to eq('is not a valid IPv6 address')
+      validator.validate("key", "", {}, errors)
+      expect(errors["key"]).to eq("is not a valid IPv6 address")
     end
 
-    it 'rejects incomplete addresses' do
+    it "rejects incomplete addresses" do
       errors = {}
-      validator.validate('key', '2001:db8:', {}, errors)
-      expect(errors['key']).to eq('is not a valid IPv6 address')
+      validator.validate("key", "2001:db8:", {}, errors)
+      expect(errors["key"]).to eq("is not a valid IPv6 address")
     end
   end
-end
+end