poro_validator 0.0.1

data/spec/lib/poro_validator/errors_spec.rb

@@ -0,0 +1,79 @@
+require 'spec_helper'
+
+RSpec.describe PoroValidator::Errors do
+  subject(:errors) { described_class.new }
+
+  describe "#add" do
+    it "adds a message stored in an array for an attribute" do
+      errors.add(:foo, "manbearpig")
+      expect(errors.on(:foo)).to eq(["manbearpig"])
+    end
+
+    it "adds additional messages for an attribute if it's already been set" do
+      errors.add(:foo, "manbearpig")
+      errors.add(:foo, "excelsior")
+      expect(errors.on(:foo)).to eq(["manbearpig", "excelsior"])
+    end
+  end
+
+  describe "#count" do
+    it "counts the messages assigned for an attribute" do
+      errors.add(:presence, "manbearpig")
+      errors.add(:presence, "magiclife")
+      errors.add(:foo, "excelsior")
+      expect(errors.count).to eq(3)
+    end
+  end
+
+  describe "#empty?" do
+    it "returns true if count is zero" do
+      expect(errors.count).to eq(0)
+      expect(errors.empty?).to be_truthy
+    end
+
+    it "returns false if count is not zero" do
+      errors.add(:presence, "manbearpig")
+      expect(errors.count).to eq(1)
+      expect(errors.empty?).to be_falsey
+    end
+  end
+
+  describe "#full_messages" do
+    before(:each) do
+      errors.add(:foo, "manbearpig")
+    end
+
+    it "returns an array" do
+      expect(errors.full_messages).to be_a(::Array)
+    end
+
+    it "returns an array of messages" do
+      expect(errors.full_messages).to eq(["foo manbearpig"])
+    end
+  end
+
+  describe "#on" do
+    context "if the key has an existing value" do
+      it "returns the message associated with the key" do
+        errors.add(:foo, "manbearpig")
+        expect(errors.on(:foo)).to eq(["manbearpig"])
+      end
+
+    end
+
+    context "if the key has no existing value" do
+      it "returns nil" do
+        expect(errors.on(:batman)).to be_nil
+      end
+    end
+  end
+
+  describe "#clear_errors" do
+    it "clears the stored error messages" do
+      errors.add(:foo, "manbearpig")
+      expect(errors.count).to eq(1)
+      errors.clear_errors
+      expect(errors.empty?).to be_truthy
+    end
+  end
+end

data/spec/lib/poro_validator/validator/base_class_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+RSpec.describe PoroValidator::Validator::BaseClass do
+  subject { described_class.new }
+
+  describe "<<" do
+    it "add/set validations" do
+      validation = [:foo, :faa]
+      subject << validation
+      expect(subject.validations).to eq([validation])
+    end
+  end
+
+  describe "#run_validations" do
+    let(:kontext) do
+      Class.new do
+        attr_accessor :entity
+      end.new
+    end
+
+    let(:klass) do
+      Class.new do
+        def __validate__(kotenxt)
+          true
+        end
+      end
+    end
+
+    context "if the conditions are matched" do
+      it "runs each validation" do
+        allow(PoroValidator::Validator::Conditions).to receive(:matched?).and_return(true)
+
+        validator1 = { validator: klass.new, conditions: [nil] }
+        validator2 = { validator: klass.new, conditions: [nil] }
+
+        subject << validator1
+        subject << validator2
+
+        expect(validator1[:validator]).to receive(:__validate__).
+          with(kontext).once
+        expect(validator2[:validator]).to receive(:__validate__).
+          with(kontext).once
+
+        subject.run_validations(kontext)
+      end
+    end
+
+    context "if the conditions are not matched" do
+      it "does not runs the validation" do
+        allow(PoroValidator::Validator::Conditions).to receive(:matched?).and_return(false)
+
+        validator = { validator: klass.new, conditions: [nil] }
+
+        subject << validator
+
+        expect(validator[:validator]).to_not receive(:__validate__)
+
+        subject.run_validations(kontext)
+      end
+    end
+  end
+end

data/spec/lib/poro_validator/validator/conditions_spec.rb

@@ -0,0 +1,112 @@
+require 'spec_helper'
+
+RSpec.describe PoroValidator::Validator::Conditions do
+  describe ".matched?" do
+    let(:entity) do
+      Class.new do
+        attr_accessor :name
+      end.new
+    end
+
+    let(:kontext) do
+      Class.new do
+        attr_accessor :entity
+      end.new
+    end
+
+    before(:each) do
+      kontext.entity = entity
+    end
+
+    context "if the conditions are matched" do
+      it "returns true" do
+        conditions = [ { if: proc { true } }, { if: proc { true } } ]
+
+        expect(described_class.matched?(conditions, kontext)).to be_truthy
+      end
+
+      context "if :unless conditions are met" do
+        it "returns true" do
+          conditions = [ { if: proc { true } }, { unless: proc { false } } ]
+
+          expect(described_class.matched?(conditions, kontext)).to be_truthy
+        end
+      end
+    end
+
+    context "if the conditions are not matched" do
+      it "returns false" do
+        conditions = [ { if: proc { true } }, { if: proc { false } } ]
+
+        expect(described_class.matched?(conditions, kontext)).to be_falsey
+      end
+
+      context "if :unless conditions are not met" do
+        it "returns true" do
+          conditions = [ { if: proc { true } }, { unless: proc { true } } ]
+
+          expect(described_class.matched?(conditions, kontext)).to be_falsey
+        end
+      end
+    end
+
+    context "if the conditions are passed in an array" do
+      it "runs each condition" do
+        condition1 = lambda { true }
+        condition2 = lambda { true }
+        conditions = [ { if: [condition1, condition2] } ]
+
+        expect(condition1).to receive(:call).once
+        expect(condition2).to receive(:call).once
+        described_class.matched?(conditions, kontext)
+      end
+    end
+
+    context "if the condition type is unknown" do
+      it "raises an exception ::PoroValidator::InvalidCondition" do
+        conditions = [ { hello: true } ]
+
+        expect do
+          described_class.matched?(conditions, kontext)
+        end.to raise_error(::PoroValidator::InvalidCondition)
+      end
+    end
+
+    context "if the condition is a String" do
+      it "evaluates the string based on the context's entity" do
+        conditions = [ { if: 'name.nil?' } ]
+
+        expect(entity).to receive(:instance_eval).with(conditions.first[:if]).once
+        described_class.matched?(conditions, kontext)
+      end
+    end
+
+    context "if the condition is a Symbol" do
+      it "calls the lambda for that condition type" do
+        conditions = [ { if: :name } ]
+
+        expect(kontext).to receive(:send).with(conditions.first[:if], entity).once
+        described_class.matched?(conditions, kontext)
+      end
+    end
+
+    context "if the condition is a Proc" do
+      it "calls the lambda/proc for that condition type" do
+        conditions = [ { if: proc { true } } ]
+
+        expect(conditions.first[:if]).to receive(:call).once
+        described_class.matched?(conditions, kontext)
+      end
+    end
+
+    context "if the condition is neither of the cases" do
+      it "raises an exception ::PoroValidator::ValidatorException" do
+        conditions = [ { if: true } ]
+
+        expect do
+          described_class.matched?(conditions, kontext)
+        end.to raise_error(::PoroValidator::InvalidCondition)
+      end
+    end
+  end
+end

data/spec/lib/poro_validator/validator/factory_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+RSpec.describe PoroValidator::Validator::Factory::Validators do
+  describe "#new" do
+    subject { described_class.set_validator(:foo_attr, validator, {}) }
+
+    context "if it finds the validator class" do
+      let(:validator) { :presence }
+
+      it "does not raise an exception" do
+        expect { subject }.to_not raise_error
+      end
+    end
+
+    context "if it does not find the validator class" do
+      let(:validator) { :foo }
+
+      it "does raise an exception" do
+        expect { subject }.to raise_error(::PoroValidator::ValidatorNotFound)
+      end
+    end
+  end
+end

data/spec/lib/poro_validator/validator/validation_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+RSpec.describe PoroValidator::Validator::Validation do
+  describe ".build" do
+    let(:options) { {} }
+    # we are defaulting to presence validator so that it does not error out
+    # if we pass in a random non existent validator for this tests
+    let(:validator) { :presence }
+
+    subject { described_class.build(:foo_attr, validator, options) }
+
+    it "returns a Validators object" do
+      expect(subject).to be_a(PoroValidator::Validators::BaseClass)
+    end
+
+    it "sets the validator to the Validator Class" do
+      expect(subject.class.name).to eq('PoroValidator::Validators::PresenceValidator')
+    end
+
+
+    context "if options is TrueClass" do
+      let(:options) { true }
+
+      it "sets the options to a hash" do
+        expect(subject.options).to eq({})
+      end
+    end
+
+    context "if options is Range" do
+      let(:options) { 1..3 }
+
+      it "sets options to a hash with an in: key with an range value" do
+        expect(subject.options).to eq({ in: 1..3 })
+      end
+    end
+
+    context "if options is Array" do
+      let(:options) { ['foo', 'faa'] }
+
+      it "sets options to a hash with an in: key with an array value" do
+        expect(subject.options).to eq({ in: ['foo', 'faa'] })
+      end
+    end
+
+    context "if options doe not match any case" do
+      let(:options) { 55 }
+
+      it "converts it to a hash with a with: key" do
+        expect(subject.options).to eq({ with: 55 })
+      end
+    end
+  end
+
+  describe "#attr_name" do
+    subject { described_class.new(:foo_attr, :foo_validator, {}) }
+
+    it "returns the attribute name" do
+      expect(subject.attr_name).to eq(:foo_attr)
+    end
+  end
+
+  describe "#validator" do
+    subject { described_class.new(:foo_attr, :foo_validator, {}) }
+
+    it "returns the validator" do
+      expect(subject.validator).to eq(:foo_validator)
+    end
+  end
+end

data/spec/lib/poro_validator/validator/validations_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+RSpec.describe PoroValidator::Validator::Validations do
+  describe ".build" do
+    subject do
+      klass = described_class.new
+      klass.build(:foo_attr, presence: true,
+                   format: /[a-z]/, if: true, unless: true)
+      klass
+    end
+
+    it "can build multiple validators" do
+      expect(subject.validations.size).to eq(2)
+    end
+
+    context "if there are nested conditions within the validator's options" do
+      subject do
+        klass = described_class.new
+        klass.build(:foo_attr, presence: { message: "hello", if: true })
+        klass
+      end
+
+      let(:validation) { subject.validations.first }
+
+      it "can select then nested condition" do
+        expect(validation[:conditions]).to eq([{ if: true }])
+      end
+
+      it "removes the nested condition from the validator options" do
+        expect(validation[:validator].options).to_not have_key(:if)
+      end
+    end
+  end
+end

data/spec/lib/poro_validator/validator_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+RSpec.describe PoroValidator::Validator do
+  describe "#validates" do
+    it "allows validations to be set" do
+      obj = Class.new do
+        include PoroValidator.validator
+
+        validates :foo, presence: true
+      end
+
+      validations = obj.send(:validations)
+
+      expect(validations.validations.count).to eq(1)
+      expect(validations.validators).to eq({presence: true})
+    end
+  end
+
+  describe "#valid?" do
+    let(:entity) { OpenStruct.new(name: nil) }
+    let(:validator) do
+      Class.new do
+        include PoroValidator.validator
+
+        validates :name, presence: true
+      end.new
+    end
+
+    context "if the entity is not valid" do
+      it "returns false" do
+        expect(validator.valid?(entity)).to be_falsey
+      end
+
+      it "returns the errors for related to the entity" do
+        validator.valid?(entity)
+        expect(validator.errors.full_messages).to eq(["name is not present"])
+      end
+    end
+
+    context "if the entity is valid" do
+      before(:each) do
+        entity.name = "manbearpig"
+      end
+
+      it "returns true" do
+        expect(validator.valid?(entity)).to be_truthy
+      end
+
+      it "returns an empty hash for the #errors" do
+        validator.valid?(entity)
+        expect(validator.errors).to be_empty
+      end
+    end
+  end
+end

data/spec/lib/poro_validator/validators/base_class_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+RSpec.describe PoroValidator::Validators::BaseClass do
+  describe "#validate" do
+    it "raises NotImplementedEror" do
+      klass = described_class.new(:foo)
+      expect { klass.validate(nil, nil, nil) }.
+        to raise_error(::PoroValidator::OverloadriddenRequired)
+    end
+  end
+end