validates_serialized 0.0.1.pre2

data/spec/validators/array_validator_spec.rb

@@ -0,0 +1,182 @@
+require 'spec_helper'
+require 'ostruct'
+
+describe ActiveModel::Validations::ArrayValidator do
+  context "#validates_array_values" do
+    class ValidatorArrayTestOne
+      include ActiveModel::Validations
+      validates_array_values :my_attr, presence: true, inclusion: { in: [1, 2, 3, 4] }
+
+      def initialize(h={})
+        h.each {|k,v| send("#{k}=",v)}
+      end
+
+      def my_attr
+        @my_attr ||= []
+      end
+
+      def my_attr=(val)
+        @my_attr = val
+      end
+    end
+
+    describe "#validate" do
+      it "does not raise error for valid value" do
+        record = ValidatorArrayTestOne.new(my_attr: [2])
+        record.valid?
+        record.errors[:my_attr].should eq([])
+      end
+
+      it "adds error for invalid value" do
+        record = ValidatorArrayTestOne.new(my_attr: [1, 5])
+        record.valid?
+        record.errors[:my_attr].should eq(["is not included in the list"])
+      end
+
+      it "adds multiple errors for invalid value" do
+        record = ValidatorArrayTestOne.new(my_attr: [nil, 1, 7])
+        record.valid?
+        record.errors[:my_attr].should eq(["can't be blank", "is not included in the list", "is not included in the list"])
+      end
+
+      it "raises error for non-array" do
+        record = ValidatorArrayTestOne.new(my_attr: 4)
+        expect { record.valid? }.to raise_error(TypeError, '4 is not an Array')
+      end
+    end
+  end
+
+  context "#validates_array_values!" do
+    class ValidatorArrayTestStrict
+      include ActiveModel::Validations
+      validates_array_values! :my_attr, presence: true, inclusion: { in: [1, 2, 3, 4] }
+
+      def initialize(h={})
+        h.each {|k,v| send("#{k}=",v)}
+      end
+
+      def my_attr
+        @my_attr ||= []
+      end
+
+      def my_attr=(val)
+        @my_attr = val
+      end
+    end
+
+    describe "#validate" do
+      it "does not raise error for valid value" do
+        record = ValidatorArrayTestStrict.new(my_attr: [2])
+        record.valid?
+        record.errors[:my_attr].should eq([])
+      end
+
+      it "raises error for invalid value" do
+        record = ValidatorArrayTestStrict.new(my_attr: [1, 5])
+        expect { record.valid? }.to raise_error(ActiveModel::StrictValidationFailed, 'My attr is not included in the list')
+      end
+
+      it "raises error for multiple invalid value" do
+        record = ValidatorArrayTestStrict.new(my_attr: [nil, 1, 7])
+        expect { record.valid? }.to raise_error(ActiveModel::StrictValidationFailed, "My attr can't be blank")
+      end
+
+      it "raises error for non-array" do
+        record = ValidatorArrayTestStrict.new(my_attr: 4)
+        expect { record.valid? }.to raise_error(TypeError, '4 is not an Array')
+      end
+    end
+  end
+
+  context "with class #validates_array_values_with" do
+    class ValidatorClassTest
+      include ActiveModel::Validations
+      validates_array_values_with ::ActiveModel::Validations::PresenceValidator, attributes: [:my_attr]
+
+      def initialize(h={})
+        h.each {|k,v| send("#{k}=",v)}
+      end
+
+      def my_attr
+        @my_attr ||= []
+      end
+
+      def my_attr=(val)
+        @my_attr = val
+      end
+    end
+
+    describe "#validate" do
+      it "does not raise error for valid value" do
+        record = ValidatorClassTest.new(my_attr: [2])
+        record.valid?
+        record.errors[:my_attr].should eq([])
+      end
+
+      it "adds error for invalid value" do
+        record = ValidatorClassTest.new(my_attr: [1, nil])
+        record.valid?
+        record.errors[:my_attr].should eq(["can't be blank"])
+      end
+
+      it "adds multiple errors for invalid value" do
+        record = ValidatorClassTest.new(my_attr: [nil, 1, nil])
+        record.valid?
+        record.errors[:my_attr].should eq(["can't be blank", "can't be blank"])
+      end
+
+      it "raises error for non-array" do
+        record = ValidatorClassTest.new(my_attr: 4)
+        expect { record.valid? }.to raise_error(TypeError, '4 is not an Array')
+      end
+    end
+  end
+
+  context "with instance #validates_array_values_with" do
+    class ValidatorInstanceTest
+      include ActiveModel::Validations
+
+      validate :instance_validations
+      def initialize(h={})
+        h.each {|k,v| send("#{k}=",v)}
+      end
+
+      def my_attr
+        @my_attr ||= []
+      end
+
+      def my_attr=(val)
+        @my_attr = val
+      end
+
+      def instance_validations
+        validates_array_values_with ::ActiveModel::Validations::PresenceValidator, attributes: [:my_attr]
+      end
+    end
+
+    describe "#validate", failing: true do
+      it "does not raise error for valid value" do
+        record = ValidatorInstanceTest.new(my_attr: [2])
+        record.valid?
+        record.errors[:my_attr].should eq([])
+      end
+
+      it "adds error for invalid value" do
+        record = ValidatorInstanceTest.new(my_attr: [1, nil])
+        record.valid?
+        record.errors[:my_attr].should eq(["can't be blank"])
+      end
+
+      it "adds multiple errors for invalid value" do
+        record = ValidatorInstanceTest.new(my_attr: [nil, 1, nil])
+        record.valid?
+        record.errors[:my_attr].should eq(["can't be blank", "can't be blank"])
+      end
+
+      it "raises error for non-array" do
+        record = ValidatorInstanceTest.new(my_attr: 4)
+        expect { record.valid? }.to raise_error(TypeError, '4 is not an Array')
+      end
+    end
+  end
+end

data/spec/validators/hash_block_validator_spec.rb

@@ -0,0 +1,98 @@
+require 'spec_helper'
+require 'ostruct'
+
+describe ActiveModel::Validations::HashBlockValidator do
+  context "#validates_hash_values" do
+    class ValidatorBlockHashTestOne
+      include ActiveModel::Validations
+
+      def initialize(h={})
+        h.each {|k,v| send("#{k}=",v)}
+      end
+
+      def my_attr
+        @my_attr ||= {}
+      end
+
+      def my_attr=(val)
+        @my_attr = val
+      end
+
+      validates_hash_keys :my_attr do
+        validates :first_key, presence: true
+        validates :second_key, inclusion: { in: [1, 2, 3, 4] }
+      end
+    end
+
+    describe "#validate" do
+      it "does not raise error for valid value" do
+        record = ValidatorBlockHashTestOne.new(my_attr: { first_key: 2, second_key: 4 })
+        record.valid?
+        record.errors[:my_attr].should eq([])
+      end
+
+      it "adds error for invalid value" do
+        record = ValidatorBlockHashTestOne.new(my_attr: { first_key: nil, second_key: 4 })
+        record.valid?
+        record.errors[:my_attr].should eq(["first_key can't be blank"])
+      end
+
+      it "adds multiple errors for multiple invalid value" do
+        record = ValidatorBlockHashTestOne.new(my_attr: { first_key: nil, second_key: 6 })
+        record.valid?
+        record.errors[:my_attr].should eq(["first_key can't be blank", "second_key is not included in the list"])
+      end
+
+      it "raises error for non-array" do
+        record = ValidatorBlockHashTestOne.new(my_attr: 4)
+        expect { record.valid? }.to raise_error(TypeError, 'my_attr is not a Hash')
+      end
+    end
+  end
+
+  context "#validates_hash_keys!" do
+    class ValidatorBlockHashTestStrict
+      include ActiveModel::Validations
+
+      def initialize(h={})
+        h.each {|k,v| send("#{k}=",v)}
+      end
+
+      def my_attr
+        @my_attr ||= {}
+      end
+
+      def my_attr=(val)
+        @my_attr = val
+      end
+
+      validates_hash_keys! :my_attr do
+        validates :first_key, presence: true
+        validates :second_key, inclusion: { in: [1, 2, 3, 4] }
+      end
+    end
+
+    describe "#validate" do
+      it "does not raise error for valid value" do
+        record = ValidatorBlockHashTestStrict.new(my_attr: {first_key: 2, second_key: 3})
+        record.valid?
+        record.errors[:my_attr].should eq([])
+      end
+
+      it "raises error for invalid value" do
+        record = ValidatorBlockHashTestStrict.new(my_attr: {first_key: 2, second_key: 5})
+        expect { record.valid? }.to raise_error(ActiveModel::StrictValidationFailed, 'second_key is not included in the list')
+      end
+
+      it "raises error for multiple invalid value" do
+        record = ValidatorBlockHashTestStrict.new(my_attr: {first_key: nil, second_key: 9})
+        expect { record.valid? }.to raise_error(ActiveModel::StrictValidationFailed, "first_key can't be blank")
+      end
+
+      it "raises error for non-array" do
+        record = ValidatorBlockHashTestStrict.new(my_attr: 4)
+        expect { record.valid? }.to raise_error(TypeError, 'my_attr is not a Hash')
+      end
+    end
+  end
+end

data/spec/validators/hash_validator_spec.rb

@@ -0,0 +1,183 @@
+require 'spec_helper'
+require 'ostruct'
+
+describe ActiveModel::Validations::HashValidator do
+  context "#validates_hash_values" do
+    class ValidatorHashTestOne
+      include ActiveModel::Validations
+
+      def initialize(h={})
+        h.each {|k,v| send("#{k}=",v)}
+      end
+
+      def my_attr
+        @my_attr ||= []
+      end
+
+      def my_attr=(val)
+        @my_attr = val
+      end
+
+      validates_hash_values :my_attr, presence: true, inclusion: { in: [1, 2, 3, 4] }
+    end
+
+    describe "#validate" do
+      it "does not raise error for valid value" do
+        record = ValidatorHashTestOne.new(my_attr: { a: 2 })
+        record.valid?
+        record.errors[:my_attr].should eq([])
+      end
+
+      it "adds error for invalid value" do
+        record = ValidatorHashTestOne.new(my_attr: { a: 1, b: 5 })
+        record.valid?
+        record.errors[:my_attr].should eq(["is not included in the list"])
+      end
+
+      it "adds multiple errors for invalid value" do
+        record = ValidatorHashTestOne.new(my_attr: { a: nil, b: 1, c: 7 })
+        record.valid?
+        record.errors[:my_attr].should eq(["can't be blank", "is not included in the list", "is not included in the list"])
+      end
+
+      it "raises error for non-array" do
+        record = ValidatorHashTestOne.new(my_attr: 4)
+        expect { record.valid? }.to raise_error(TypeError, '4 is not a Hash')
+      end
+    end
+  end
+
+  context "#validates_hash_values!" do
+    class ValidatorHashTestStrict
+      include ActiveModel::Validations
+      validates_hash_values! :my_attr, presence: true, inclusion: { in: [1, 2, 3, 4] }
+
+      def initialize(h={})
+        h.each {|k,v| send("#{k}=",v)}
+      end
+
+      def my_attr
+        @my_attr ||= []
+      end
+
+      def my_attr=(val)
+        @my_attr = val
+      end
+    end
+
+    describe "#validate" do
+      it "does not raise error for valid value" do
+        record = ValidatorHashTestStrict.new(my_attr: {a: 2})
+        record.valid?
+        record.errors[:my_attr].should eq([])
+      end
+
+      it "raises error for invalid value" do
+        record = ValidatorHashTestStrict.new(my_attr: {a: 1, b: 5})
+        expect { record.valid? }.to raise_error(ActiveModel::StrictValidationFailed, 'My attr is not included in the list')
+      end
+
+      it "raises error for multiple invalid value" do
+        record = ValidatorHashTestStrict.new(my_attr: {a: nil, b: 1, c: 7})
+        expect { record.valid? }.to raise_error(ActiveModel::StrictValidationFailed, "My attr can't be blank")
+      end
+
+      it "raises error for non-array" do
+        record = ValidatorHashTestStrict.new(my_attr: 4)
+        expect { record.valid? }.to raise_error(TypeError, '4 is not a Hash')
+      end
+    end
+  end
+
+  context "with class #validates_hash_values_with" do
+    class ValidatorHashClassTest
+      include ActiveModel::Validations
+      validates_hash_values_with ::ActiveModel::Validations::PresenceValidator, attributes: [:my_attr]
+
+      def initialize(h={})
+        h.each {|k,v| send("#{k}=",v)}
+      end
+
+      def my_attr
+        @my_attr ||= []
+      end
+
+      def my_attr=(val)
+        @my_attr = val
+      end
+    end
+
+    describe "#validate" do
+      it "does not raise error for valid value" do
+        record = ValidatorHashClassTest.new(my_attr: {a: 2})
+        record.valid?
+        record.errors[:my_attr].should eq([])
+      end
+
+      it "adds error for invalid value" do
+        record = ValidatorHashClassTest.new(my_attr: {a: 1, b: nil})
+        record.valid?
+        record.errors[:my_attr].should eq(["can't be blank"])
+      end
+
+      it "adds multiple errors for invalid value" do
+        record = ValidatorHashClassTest.new(my_attr: {a: nil, b: 1, c: nil})
+        record.valid?
+        record.errors[:my_attr].should eq(["can't be blank", "can't be blank"])
+      end
+
+      it "raises error for non-array" do
+        record = ValidatorHashClassTest.new(my_attr: 4)
+        expect { record.valid? }.to raise_error(TypeError, '4 is not a Hash')
+      end
+    end
+  end
+
+  context "with instance #validates_hash_values_with" do
+    class ValidatorHashInstanceTest
+      include ActiveModel::Validations
+
+      validate :instance_validations
+      def initialize(h={})
+        h.each {|k,v| send("#{k}=",v)}
+      end
+
+      def my_attr
+        @my_attr ||= []
+      end
+
+      def my_attr=(val)
+        @my_attr = val
+      end
+
+      def instance_validations
+        validates_hash_values_with ::ActiveModel::Validations::PresenceValidator, attributes: [:my_attr]
+      end
+    end
+
+    describe "#validate" do
+      it "does not raise error for valid value" do
+        record = ValidatorHashInstanceTest.new(my_attr: {a: 2})
+        record.valid?
+        record.errors[:my_attr].should eq([])
+      end
+
+      it "adds error for invalid value" do
+        record = ValidatorHashInstanceTest.new(my_attr: {a: 1, b: nil})
+        record.valid?
+        record.errors[:my_attr].should eq(["can't be blank"])
+      end
+
+      it "adds multiple errors for invalid value" do
+        record = ValidatorHashInstanceTest.new(my_attr: {a: nil, b: 1, c: nil})
+        record.valid?
+        record.errors[:my_attr].should eq(["can't be blank", "can't be blank"])
+      end
+
+      it "raises error for non-array" do
+        record = ValidatorHashInstanceTest.new(my_attr: 4)
+        expect { record.valid? }.to raise_error(TypeError, '4 is not a Hash')
+      end
+    end
+  end
+end