aequitas 0.0.1

data/spec/unit/aequitas/rule_spec.rb

@@ -0,0 +1,40 @@
+require_relative '../../spec_helper'
+require 'aequitas/rule'
+
+module Aequitas
+  describe Rule do
+    let(:rule) { Rule.new(attribute_name, options) }
+    let(:attribute_name) { :foo }
+    let(:options) { Hash.new }
+
+    describe '#initialize' do
+      it 'sets #attribute_name to the first arg' do
+        attribute_name = :foo
+        assert_same attribute_name, Rule.new(attribute_name).attribute_name
+      end
+
+      it 'sets #custom_message to the :message option' do
+        message = 'foo'
+        assert_same message, Rule.new(:bar, message: message).custom_message
+      end
+
+      it 'initializes #guard with the :if and :unless options' do
+        expected_guard = Rule::Guard.new(if: :a, unless: :b)
+        assert_equal expected_guard, Rule.new(:bar, if: :a, unless: :b).guard
+      end
+    end
+
+    describe '#validate' do
+      
+    end
+
+    describe '#execute?' do
+      
+    end
+
+    describe '#skip?' do
+      
+    end
+
+  end
+end

data/spec/unit/aequitas/support/blank_spec.rb

@@ -0,0 +1,83 @@
+require_relative '../../../spec_helper'
+require 'aequitas/support/blank'
+
+module Aequitas
+  describe '.blank?' do
+    it 'returns true when testing nil' do
+      assert_operator Aequitas, :blank?, nil
+    end
+
+    it 'returns true when testing false' do
+      assert_operator Aequitas, :blank?, false
+    end
+
+    it 'returns false when testing a Numeric' do
+      refute_operator Aequitas, :blank?, 1
+    end
+
+    it 'returns false when testing true' do
+      refute_operator Aequitas, :blank?, true
+    end
+
+    it 'returns true when testing an empty Hash' do
+      assert_operator Aequitas, :blank?, {}
+    end
+
+    it 'returns true when testing an empty Array' do
+      assert_operator Aequitas, :blank?, []
+    end
+
+    it 'returns false when testing an non-empty Hash' do
+      refute_operator Aequitas, :blank?, { foo: :bar }
+    end
+
+    it 'returns false when testing an non-empty Array' do
+      refute_operator Aequitas, :blank?, [:foo]
+    end
+
+    it 'returns true when testing an empty String' do
+      assert_operator Aequitas, :blank?, ''
+    end
+
+    it 'returns true when testing a String with only whitespace' do
+      assert_operator Aequitas, :blank?, "\n"
+    end
+
+    it 'returns false when testing a non-empty String' do
+      refute_operator Aequitas, :blank?, 'target'
+    end
+
+    it 'returns true when #nil? is true for the argument' do
+      target = MiniTest::Mock.new
+      target.expect(:nil?, true)
+      assert_operator Aequitas, :blank?, target
+    end
+
+    it 'returns false when #nil? is false for the argument' do
+      target = MiniTest::Mock.new
+      target.expect(:nil?, false)
+      refute_operator Aequitas, :blank?, target
+    end
+
+    it 'returns false when #nil? is false and the argument does not respond to #empty?' do
+      target = MiniTest::Mock.new
+      target.expect(:nil?, false)
+      refute_operator Aequitas, :blank?, target
+    end
+
+    it 'returns false when #nil? is false and the argument is not empty' do
+      target = MiniTest::Mock.new
+      target.expect(:nil?, false)
+      target.expect(:empty?, false)
+      refute_operator Aequitas, :blank?, target
+    end
+
+    it 'returns true when #nil? is false and the argument is empty' do
+      target = MiniTest::Mock.new
+      target.expect(:nil?, false)
+      target.expect(:empty?, true)
+      assert_operator Aequitas, :blank?, target
+    end
+
+  end
+end

data/spec/unit/aequitas/support/equalizable/equalizer_spec.rb

@@ -0,0 +1,21 @@
+require_relative '../../../../spec_helper'
+require 'aequitas/support/equalizable'
+
+module Aequitas
+  describe Equalizable::Equalizer do
+    let(:equalizer) { Equalizable::Equalizer.new(keys) }
+    let(:keys) { [:a, :b, :c] }
+
+    describe '#initialize' do
+      it "doesn't raise" do
+        assert_kind_of Equalizable::Equalizer, equalizer
+      end
+    end
+
+    describe '#keys' do
+      it 'returns the values that the Equalizer was initialized with' do
+        assert_equal [:a, :b, :c], equalizer.keys
+      end
+    end
+  end
+end

data/spec/unit/aequitas/support/equalizable_spec.rb

@@ -0,0 +1,67 @@
+require_relative '../../../spec_helper'
+require 'aequitas/support/equalizable'
+
+module Aequitas
+  describe Equalizable do
+    let(:equalizable_test_class) do
+      Class.new do
+        extend Equalizable
+
+        equalize_on :foo, :bar
+
+        attr_reader :foo, :bar, :baz
+
+        def initialize(foo, bar, baz)
+          @foo, @bar, @baz = foo, bar, baz
+        end
+      end
+    end
+
+    describe '.equalizer' do
+      it 'returns the Equalizer module for the class' do
+        assert_instance_of Equalizable::Equalizer,
+          equalizable_test_class.equalizer
+      end
+    end
+
+    describe '.equalizer.keys' do
+      it 'returns the keys that the class is equalized on' do
+        assert_equal [:foo, :bar], equalizable_test_class.equalizer.keys
+      end
+    end
+
+    describe 'when all equalized attributes are the same' do
+      let(:first)  { equalizable_test_class.new(:a, :b, :c) }
+      let(:second) { equalizable_test_class.new(:a, :b, :d) }
+
+      describe '#eql?' do
+        it 'returns true' do
+          assert first.eql?(second), 'expected first.eql?(second) to be true'
+        end
+      end
+
+      describe '#==' do
+        it 'returns true' do
+          assert_equal first, second
+        end
+      end
+    end
+
+    describe 'when an equalized attribute is different' do
+      let(:first)  { equalizable_test_class.new(:a, :b, :c) }
+      let(:second) { equalizable_test_class.new(:a, :c, :d) }
+
+      describe '#eql?' do
+        it 'returns false' do
+          refute first.eql?(second), 'expected first.eql?(second) to be false'
+        end
+      end
+
+      describe '#==' do
+        it 'returns false' do
+          refute_equal first, second
+        end
+      end
+    end
+  end
+end

data/spec/unit/aequitas/violation_set_spec.rb

@@ -0,0 +1,154 @@
+require_relative '../../spec_helper'
+require 'aequitas/violation_set'
+
+module Aequitas
+  describe ViolationSet do
+    let(:object) { Object.new }
+    let(:violation_set) { ViolationSet.new(object) }
+
+    describe '#initialize' do
+      it 'does not raise any errors' do
+        # TODO: implement JUnit-style #assert_that and matchers:
+        # assert_that violation_set, is(:kind_of?, ViolationSet)
+        assert_kind_of ViolationSet, violation_set
+      end
+    end
+
+    describe '#on' do
+      let(:violation) { Violation.new(object, 'message', nil, :attribute) }
+
+      it 'returns nil when no error is present on the requested attribute' do
+        assert_nil violation_set.on(:foo)
+      end
+
+      describe 'after adding a message via a symbol attribute name' do
+        it 'returns the message that was added (as a Violation)' do
+          violation_set.add(:attribute, 'message')
+
+          assert_equal [violation], violation_set.on(:attribute)
+        end
+      end
+
+      describe 'after adding a message via a string attribute name' do
+        it 'returns the message that was added when accessed via symbol' do
+          skip 'convert to handling attribute names as strings'
+          violation_set.add('attribute', 'message')
+
+          assert_equal [violation], violation_set.on('attribute')
+          # assert_equal [violation], violation_set.on(:attribute)
+        end
+      end
+    end
+
+    describe '#add' do
+      let(:violation_1) { Violation.new(object, 'message 1', nil, :attribute) }
+      let(:violation_2) { Violation.new(object, 'message 2', nil, :attribute) }
+
+      it 'returns the receiver' do
+        # assert_that violation_set.add(:foo, 'message'), is(:equal?, violation_set)
+        assert_same violation_set, violation_set.add(:foo, 'message')
+      end
+
+      describe 'after adding a single message' do
+        it 'is is accessible via #on' do
+          violation_set.add(violation_1.attribute_name, violation_1.custom_message)
+
+          assert_equal [violation_1], violation_set.on(violation_1.attribute_name)
+        end
+      end
+
+      describe 'after adding a single Violation' do
+        it 'is is accessible via #on' do
+          violation_set.add(violation_1)
+
+          assert_equal [violation_1], violation_set.on(:attribute)
+        end
+      end
+
+      describe 'after adding a second message' do
+        it 'returns the violations via #on in the order they were added' do
+          violation_set.add(violation_1.attribute_name, violation_1.custom_message)
+          violation_set.add(violation_2.attribute_name, violation_2.custom_message)
+
+          assert_equal [violation_1, violation_2], violation_set.on(:attribute)
+        end
+      end
+
+      describe 'after adding the same message twice' do
+        it 'returns a single instance of that message via #on' do
+          violation_set.add(:attribute, 'message')
+          violation_set.add(:attribute, 'message')
+
+          assert_equal violation_set.on(:attribute), ['message']
+        end
+      end
+
+      describe 'after adding a second Violation' do
+        it 'returns the violations via #on in the order they were added' do
+          violation_set.add(violation_1)
+          violation_set.add(violation_2)
+
+          assert_equal [violation_1, violation_2], violation_set.on(:attribute)
+        end
+      end
+
+      describe 'after adding an equivalent Violation twice' do
+        let(:violation_1) { Violation.new(object, 'message', nil, :attribute) }
+        let(:violation_2) { Violation.new(object, 'message', nil, :attribute) }
+
+        it 'returns a single instance of that message via #on' do
+          violation_set.add(violation_1)
+          violation_set.add(violation_2)
+
+          assert_equal [violation_1], violation_set.on(:attribute)
+        end
+      end
+    end
+
+    describe '#empty?' do
+      it 'is initially true' do
+        # TODO: implement JUnit-style #assert_that and matchers
+        # assert_that violation_set, is(:empty?)
+        assert_predicate violation_set, :empty?
+      end
+
+      describe 'after calling #on' do
+        it 'is true' do
+          violation_set.on(:attribute)
+          assert_predicate violation_set, :empty?
+        end
+      end
+
+      describe 'after adding a message' do
+        it 'is false' do
+          violation_set.add(:attribute, 'message')
+          refute_predicate violation_set, :empty?
+        end
+      end
+
+      describe 'after adding a Violation' do
+        let(:violation) { Violation.new(object, 'message', nil, :attribute) }
+
+        it 'is false' do
+          violation_set.add(violation)
+          refute_predicate violation_set, :empty?
+        end
+      end
+    end
+
+    describe '#each' do
+      let(:violation_1) { Violation.new(object, 'message 1', nil, :attribute) }
+      let(:violation_2) { Violation.new(object, 'message 2', nil, :attribute) }
+      let(:violation_3) { Violation.new(object, 'another message', nil, :foo) }
+
+      it 'iterates over properties and yields error message arrays' do
+        violation_set.add(violation_1)
+        violation_set.add(violation_2)
+        violation_set.add(violation_3)
+
+        expected = [[violation_1, violation_2], [violation_3]]
+        assert_equal expected, violation_set.inject([]) { |mem, var| mem << var }
+      end
+    end
+  end
+end

data/spec_legacy/fixtures/barcode.rb

@@ -0,0 +1,40 @@
+module DataMapper
+  module Validation
+    module Fixtures
+      class Barcode
+        attr_accessor :valid_hook_call_count
+
+        #
+        # Behaviors
+        #
+
+        include DataMapper::Resource
+
+        #
+        # Properties
+        #
+
+        without_auto_validations do
+          property :code, String, :key => true
+        end
+
+        #
+        # Validations
+        #
+
+        validates_length_of :code, :max => 10
+
+        def self.valid_instance
+          new(:code => "3600029145")
+        end
+
+        # measure the number of times #valid? is executed
+        before :valid? do
+          @valid_hook_call_count ||= 0
+          @valid_hook_call_count += 1
+        end
+
+      end # Barcode
+    end
+  end
+end

data/spec_legacy/fixtures/basketball_court.rb

@@ -0,0 +1,58 @@
+# -*- coding: utf-8 -*-
+
+module DataMapper
+  module Validation
+    module Fixtures
+      class BasketballCourt
+        #
+        # Behaviors
+        #
+
+        include DataMapper::Resource
+
+        #
+        # Properties
+        #
+
+        property :id,     Serial
+
+        without_auto_validations do
+          property :name,   String
+
+          property :length, Float
+          property :width,  Float
+
+          property :three_point_line_distance,  Float
+          property :free_throw_line_distance,   Float
+          property :rim_height,                 Float
+        end
+
+        #
+        # Validations
+        #
+
+        # obviously these are all metrics
+        validates_numericality_of :length, :gte => 15.0,  :lte => 15.24
+        validates_numericality_of :width,  :gte => 25.28, :lte => 28.65
+
+        # 3 pt line distance may use :gte and :lte, but for
+        # sake of spec example we make it up a little
+        validates_numericality_of :three_point_line_distance, :gt => 6.7, :lt => 7.24
+        validates_numericality_of :free_throw_line_distance,  :equals => 4.57
+        validates_numericality_of :rim_height,                :eq     => 3.05
+
+        def self.valid_instance(overrides = {})
+          defaults = {
+            :length                    => 15.24,
+            :width                     => 28.65,
+            :free_throw_line_distance  => 4.57,
+            :rim_height                => 3.05,
+            :three_point_line_distance => 6.9
+          }
+
+          new(defaults.merge(overrides))
+        end
+      end
+    end # Fixtures
+  end # Validations
+end # DataMapper