aequitas 0.0.1

data/spec/integration/virtus/string/presence_spec.rb

@@ -0,0 +1,49 @@
+require_relative '../../../spec_helper'
+require 'virtus'
+require 'aequitas'
+require 'aequitas/virtus'
+
+describe Aequitas::Virtus::ClassMethodOverrides do
+  let(:class_under_test) do
+    Class.new do
+      include Virtus
+      include Aequitas
+
+      attribute :validated_attribute, String, :required => true
+
+      self
+    end
+  end
+
+  describe '.validation_rules' do
+    it 'includes a Rule::Presence::NotBlank for :validated_attribute' do
+      attribute_rules = class_under_test.validation_rules[:validated_attribute]
+      refute_predicate attribute_rules, :empty?
+      assert_instance_of Aequitas::Rule::Presence::NotBlank, attribute_rules.first
+    end
+  end
+
+  describe '#valid?' do
+    subject { class_under_test.new(:validated_attribute => attribute_value) }
+
+    describe 'when empty string' do
+      let(:attribute_value) { '' }
+      it('is not valid') { refute_predicate subject, :valid? }
+    end
+
+    describe 'when nil' do
+      let(:attribute_value) { nil }
+      it('is not valid') { refute_predicate subject, :valid? }
+    end
+
+    describe 'when a non-empty string' do
+      let(:attribute_value) { 'foo' }
+      it('is valid') { assert_predicate subject, :valid? }
+    end
+
+    describe 'when true' do
+      let(:attribute_value) { true }
+      it('is valid') { assert_predicate subject, :valid? }
+    end
+  end
+end

data/spec/rcov.opts

@@ -0,0 +1,6 @@
+--exclude "spec,^/"
+--sort coverage
+--callsites
+--xrefs
+--profile
+--text-summary

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+gem 'minitest', '~>2.8'
+
+require 'minitest/autorun'
+
+$LOAD_PATH << File.expand_path('../../lib', __FILE__)

data/spec/suite.rb

@@ -0,0 +1,5 @@
+spec_dir = File.expand_path('..', __FILE__)
+
+%w[unit integration].each do |spec_type|
+  Dir[File.join(spec_dir, spec_type, '**', '*.rb')].each { |spec| require spec }
+end

data/spec/unit/aequitas/rule/absence/blank_spec.rb

@@ -0,0 +1,45 @@
+require_relative '../../../../spec_helper'
+require 'aequitas/rule/absence/blank'
+
+describe Aequitas::Rule::Absence::Blank do
+  subject { Aequitas::Rule::Absence::Blank.new(attribute_name, options) }
+  let(:attribute_name) { :foo }
+  let(:options) { Hash.new }
+
+  describe '#valid?' do
+    let(:resource) { MiniTest::Mock.new }
+
+    it "is false if the target's attribute is a non-empty string" do
+      resource.expect(:validation_attribute_value, 'a', [attribute_name])
+      refute_operator subject, :valid?, resource
+    end
+
+    it "is false if the target's attribute is a symbol" do
+      resource.expect(:validation_attribute_value, :a, [attribute_name])
+      refute_operator subject, :valid?, resource
+    end
+
+    it "is true if the target's attribute is an empty string" do
+      resource.expect(:validation_attribute_value, '', [attribute_name])
+      assert_operator subject, :valid?, resource
+    end
+
+    it "is true if the target's attribute is false" do
+      resource.expect(:validation_attribute_value, false, [attribute_name])
+      assert_operator subject, :valid?, resource
+    end
+
+    it "is true if the target's attribute is nil" do
+      resource.expect(:validation_attribute_value, nil, [attribute_name])
+      assert_operator subject, :valid?, resource
+    end
+  end
+
+  describe '#violation_type' do
+    it 'returns :absent' do
+      resource = MiniTest::Mock.new
+      assert_equal :not_blank, subject.violation_type(resource)
+    end
+  end
+
+end

data/spec/unit/aequitas/rule/acceptance_spec.rb

@@ -0,0 +1,71 @@
+require_relative '../../../spec_helper'
+require 'aequitas/rule/acceptance'
+
+module Aequitas
+  class Rule
+    describe Acceptance do
+      subject { Acceptance.new(attribute_name, options) }
+      let(:attribute_name) { :foo }
+      let(:options) { Hash.new }
+
+      describe '#initialize' do
+        describe 'when the :accept option is present' do
+          let(:options) { { accept: [:foo] } }
+
+          it 'sets #accept to the provided value' do
+            assert_equal [:foo], subject.accept
+          end
+        end
+
+        describe 'when the :accept option is not present' do
+          let(:options) { Hash.new }
+
+          it 'sets #accept to the default accepted values' do
+            assert_equal Acceptance::DEFAULT_ACCEPTED_VALUES, subject.accept
+          end
+        end
+
+        describe 'when the :allow_nil option is absent' do
+          it 'sets allow_nil? to true' do
+            assert_predicate subject.skip_condition, :allow_nil?
+          end
+        end
+
+        describe 'when the :allow_nil option is false' do
+          let(:options) { { allow_nil: false } }
+
+          it 'sets allow_nil? to false' do
+            refute_predicate subject.skip_condition, :allow_nil?
+          end
+        end
+      end
+
+      describe '#valid?' do
+        let(:resource) { MiniTest::Mock.new }
+        let(:options) { { accept: ['a'] } }
+
+        describe "when the target attribute's value is among the #accept values" do
+          it 'returns true' do
+            resource.expect(:validation_attribute_value, 'a', [attribute_name])
+            assert_operator subject, :valid?, resource
+          end
+        end
+
+        describe "when the target attribute's value is not among the #accept values" do
+          it 'returns false' do
+            resource.expect(:validation_attribute_value, 'b', [attribute_name])
+            refute_operator subject, :valid?, resource
+          end
+        end
+      end
+
+      describe '#violation_type' do
+        it 'returns :accepted' do
+          resource = MiniTest::Mock.new
+          assert_equal :accepted, subject.violation_type(resource)
+        end
+      end
+
+    end
+  end # class Rule
+end # module Aequitas

data/spec/unit/aequitas/rule/confirmation_spec.rb

@@ -0,0 +1,80 @@
+require_relative '../../../spec_helper'
+require 'aequitas/rule/confirmation'
+
+module Aequitas
+  class Rule
+    describe Confirmation do
+      subject { Confirmation.new(attribute_name, options) }
+      let(:attribute_name) { :foo }
+      let(:options) { {} }
+
+      describe '#initialize' do
+        it 'calls #default_to_allowing_nil! on its skip_condition' do
+          skip_condition = MiniTest::Mock.new
+          skip_condition.expect(:default_to_allowing_nil!,   nil)
+          skip_condition.expect(:default_to_allowing_blank!, nil)
+          Confirmation.new(:foo, skip_condition: skip_condition)
+        end
+
+        it 'calls #default_to_allowing_blank! on its skip_condition' do
+          skip_condition = MiniTest::Mock.new
+          skip_condition.expect(:default_to_allowing_nil!,   nil)
+          skip_condition.expect(:default_to_allowing_blank!, nil)
+          Confirmation.new(:foo, skip_condition: skip_condition)
+        end
+      end
+
+      describe '#valid?' do
+        let(:resource) { MiniTest::Mock.new }
+        let(:options) { { skip_condition: MiniTest::Mock.new } }
+        let(:attribute_value) { :bar }
+
+        before do
+          resource.expect(:validation_attribute_value, attribute_value, [attribute_name])
+          options[:skip_condition].expect(:default_to_allowing_nil!, nil)
+          options[:skip_condition].expect(:default_to_allowing_blank!, nil)
+        end
+
+        describe 'when #skip? returns true' do
+          before { options[:skip_condition].expect(:skip?, true, [attribute_value]) }
+
+          it 'returns true' do
+
+            assert_operator subject, :valid?, resource
+          end
+        end
+
+        describe 'when #skip? returns false' do
+          describe 'and the value equals the confirmation value' do
+            before do
+              options[:skip_condition].expect(:skip?, false, [attribute_value])
+              resource.expect(:instance_variable_get, attribute_value, ["@#{attribute_name}_confirmation"])
+            end
+
+            it 'returns true' do
+              assert_operator subject, :valid?, resource
+            end
+          end
+
+          describe 'and the value does not equal the confirmation value' do
+            before do
+              options[:skip_condition].expect(:skip?, false, [attribute_value])
+              resource.expect(:instance_variable_get, "#{attribute_value}asdf", ["@#{attribute_name}_confirmation"])
+            end
+
+            it 'returns false' do
+              refute_operator subject, :valid?, resource
+            end
+          end
+        end
+      end
+
+      describe 'violation_type' do
+        it 'returns :confirmation' do
+          assert_equal :confirmation, subject.violation_type(MiniTest::Mock.new)
+        end
+      end
+
+    end
+  end # class Rule
+end # module Aequitas

data/spec/unit/aequitas/rule/guard_spec.rb

@@ -0,0 +1,120 @@
+require_relative '../../../spec_helper'
+require 'aequitas/rule/guard'
+
+module Aequitas
+  class Rule
+    describe Guard do
+      describe '#initialize' do
+        it 'stores the :if option as #if_test' do
+          expected = 'foo'
+          assert_same expected, Guard.new(if: expected).if_test
+        end
+
+        it 'stores the :unless option as #unless_test' do
+          expected = 'foo'
+          assert_same expected, Guard.new(unless: expected).unless_test
+        end
+      end
+
+      describe '#allow?' do
+        let(:rule_guard) { Guard.new(if: if_test, unless: unless_test) }
+        let(:if_test) { nil }
+        let(:unless_test) { nil }
+
+        describe 'when #if_test is present' do
+          let(:if_test) { MiniTest::Mock.new }
+
+          describe 'and #if_test responds to #call' do
+            it 'invokes #call on the #if_test' do
+              if_test.expect(:call, nil, [Object])
+              rule_guard.allow?(Object.new)
+            end
+          end
+
+          describe 'and #if_test is a Symbol' do
+            let(:if_test) { :foo }
+
+            it 'invokes the message identified by #if_test on the argument' do
+              arg = MiniTest::Mock.new
+              arg.expect(:foo, nil)
+              rule_guard.allow?(arg)
+            end
+          end
+
+          describe 'and evaluating #if_test results in a truthy value' do
+            it 'returns true' do
+              if_test.expect(:call, Object.new, [Object])
+              assert_operator rule_guard, :allow?, Object.new
+            end
+          end
+
+          describe 'and evaluating #if_test results in a falsy value' do
+            it 'returns false' do
+              if_test.expect(:call, nil, [Object])
+              refute_operator rule_guard, :allow?, Object.new
+            end
+          end
+        end
+
+        describe 'when #unless_test is present' do
+          let(:unless_test) { MiniTest::Mock.new }
+
+          describe 'and #unless_test responds to #call' do
+            it 'invokes #call on the clause' do
+              unless_test.expect(:call, nil, [Object])
+              rule_guard.allow?(Object.new)
+            end
+          end
+
+          describe 'and #unless_test is a Symbol' do
+            let(:unless_test) { :foo }
+
+            it 'invokes the message identified by #unless_test on the argument' do
+              arg = MiniTest::Mock.new
+              arg.expect(:foo, nil)
+              rule_guard.allow?(arg)
+            end
+          end
+
+          describe 'and evaluating #unless_test results in a truthy value' do
+            it 'returns false' do
+              unless_test.expect(:call, Object.new, [Object])
+              refute_operator rule_guard, :allow?, Object.new
+            end
+          end
+
+          describe 'and evaluating #unless_test results in a falsy value' do
+            it 'returns true if #call returns something falsy' do
+              unless_test.expect(:call, nil, [Object])
+              assert_operator rule_guard, :allow?, Object.new
+            end
+          end
+        end
+
+        describe 'when both #if_test and #unless_test are present' do
+          let(:if_test)     { MiniTest::Mock.new }
+          let(:unless_test) { MiniTest::Mock.new }
+
+          describe 'and #if_test responds to #call' do
+            it 'invokes #call on #if_test and ignores #unless_test' do
+              arg = MiniTest::Mock.new
+              if_test.expect(:call, nil, [Object])
+              rule_guard.allow?(arg)
+            end
+          end
+
+          describe 'and #if_test is a Symbol' do
+            let(:if_test) { :foo }
+
+            it 'invokes the message identified by #if_test on the argument and ignores #unless_test' do
+              arg = MiniTest::Mock.new
+              arg.expect(:foo, nil)
+              rule_guard.allow?(arg)
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

data/spec/unit/aequitas/rule/skip_condition_spec.rb

@@ -0,0 +1,170 @@
+require_relative '../../../spec_helper'
+require 'aequitas/rule/skip_condition'
+
+module Aequitas
+  class Rule
+    describe SkipCondition do
+      subject { SkipCondition.new(options) }
+
+      describe '#initialize' do
+        describe 'when :allow_nil is included and false' do
+          let(:options) { { allow_nil: false } }
+          
+        end
+      end
+
+      describe '#skip?' do
+        it 'is false when :allow_nil is absent and the value is nil' do
+          refute_operator SkipCondition.new, :skip?, nil
+        end
+
+        it 'is false when :allow_nil is absent and the value is not nil' do
+          refute_operator SkipCondition.new, :skip?, :foo
+        end
+
+        it 'is true when :allow_nil is true and the value is nil' do
+          assert_operator SkipCondition.new(allow_nil: true), :skip?, nil
+        end
+
+        it 'is false when :allow_nil is true and the value is non-nil' do
+          refute_operator SkipCondition.new(allow_nil: true), :skip?, :foo
+        end
+
+        it 'is false when :allow_nil is false and the value is nil' do
+          refute_operator SkipCondition.new(allow_nil: false), :skip?, nil
+        end
+
+        it 'is false when :allow_nil is false and the value is non-nil' do
+          refute_operator SkipCondition.new(allow_nil: false), :skip?, :foo
+        end
+
+        it 'is true when :allow_blank is true and the value is nil' do
+          assert_operator SkipCondition.new(allow_blank: true), :skip?, nil
+        end
+
+        it 'is false when :allow_blank is true and the value is non-nil' do
+          refute_operator SkipCondition.new(allow_blank: true), :skip?, :foo
+        end
+      end
+
+      describe '#allow_nil?' do
+        it 'is false when :allow_nil option is absent' do
+          refute_predicate SkipCondition.new, :allow_nil?
+        end
+
+        it 'is false when :allow_nil option is false' do
+          refute_predicate SkipCondition.new(allow_nil: false), :allow_nil?
+        end
+
+        it 'is true when :allow_nil option is true' do
+          assert_predicate SkipCondition.new(allow_nil: true), :allow_nil?
+        end
+      end
+
+      describe '#allow_blank?' do
+        it 'is false when :allow_blank option is absent' do
+          refute_predicate SkipCondition.new, :allow_blank?
+        end
+
+        it 'is false when :allow_blank option is false' do
+          refute_predicate SkipCondition.new(allow_blank: false), :allow_blank?
+        end
+
+        it 'is true when :allow_blank option is true' do
+          assert_predicate SkipCondition.new(allow_blank: true), :allow_blank?
+        end
+      end
+
+      describe '#allow_nil!' do
+        subject { SkipCondition.new }
+
+        it 'returns the receiver' do
+          assert_same subject, subject.allow_nil!
+        end
+
+        it 'configures the receiver to allow nil' do
+          subject.allow_nil!
+          assert_predicate subject, :allow_nil?
+        end
+      end
+
+      describe '#allow_blank!' do
+        subject { SkipCondition.new }
+
+        it 'returns the receiver' do
+          assert_same subject, subject.allow_blank!
+        end
+
+        it 'configures the receiver to allow blank' do
+          subject.allow_blank!
+          assert_predicate subject, :allow_blank?
+        end
+      end
+
+      describe '#reject_nil!' do
+        subject { SkipCondition.new }
+
+        it 'returns the receiver' do
+          assert_same subject, subject.reject_nil!
+        end
+
+        it 'configures the receiver to reject nil' do
+          subject.reject_nil!
+          refute_predicate subject, :allow_nil?
+        end
+      end
+
+      describe '#reject_blank!' do
+        subject { SkipCondition.new }
+
+        it 'returns the receiver' do
+          assert_same subject, subject.reject_blank!
+        end
+
+        it 'configures the receiver to reject blank' do
+          subject.reject_blank!
+          refute_predicate subject, :allow_blank?
+        end
+      end
+
+      describe '#default_to_allowing_nil!' do
+        subject { SkipCondition.new }
+
+        it 'returns the receiver' do
+          assert_same subject, subject.default_to_allowing_nil!
+        end
+
+        it 'configures the receiver to allow nil if not configured' do
+          subject.default_to_allowing_nil!
+          assert_predicate subject, :allow_nil?
+        end
+
+        it 'does not configure the receiver to allow nil if already configured' do
+          subject.reject_nil!
+          subject.default_to_allowing_nil!
+          refute_predicate subject, :allow_nil?
+        end
+      end
+
+      describe '#default_to_allowing_blank!' do
+        subject { SkipCondition.new }
+
+        it 'returns the receiver' do
+          assert_same subject, subject.default_to_allowing_blank!
+        end
+
+        it 'configures the receiver to allow blank' do
+          subject.default_to_allowing_blank!
+          assert_predicate subject, :allow_blank?
+        end
+
+        it 'does not configure the receiver to allow blank if already configured' do
+          subject.reject_blank!
+          subject.default_to_allowing_blank!
+          refute_predicate subject, :allow_blank?
+        end
+      end
+
+    end
+  end
+end