ward 0.1.0

data/spec/ward/errors_spec.rb

@@ -0,0 +1,149 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe Ward::Errors do
+  subject { Ward::Errors }
+
+  it 'should be enumerable' do
+    Ward::Errors.ancestors.should include(Enumerable)
+  end
+
+  it { should have_public_method_defined(:each) }
+
+  describe '#each' do
+    it 'should yield each invalid attribute' do
+      errors = Ward::Errors.new
+      errors.add(:one, 'Whoops')
+      errors.add(:two, 'Whoops')
+
+      attributes = errors.map { |attribute, _| attribute }
+      attributes.should include(:one)
+      attributes.should include(:two)
+    end
+  end
+
+  #
+  # add
+  #
+
+  describe '#add' do
+    it 'should return the message which was set' do
+      Ward::Errors.new.add(:name, 'Whoops').should == 'Whoops'
+    end
+  end
+
+  #
+  # on
+  #
+
+  it { should have_public_method_defined(:on) }
+
+  describe '#on' do
+
+    describe 'when there is one error keyed on an attribute name' do
+      before(:all) do
+        @errors = Ward::Errors.new
+        @errors.add(:name, 'Name should not fail')
+      end
+
+      it 'should return nil when no error is present on the attribute' do
+        @errors.on(:__invalid__).should be_nil
+      end
+
+      it 'return a string when an error is present on the attribute' do
+        @errors.on(:name).should == ['Name should not fail']
+      end
+    end # when there is one error keyed on an attribute name
+
+    describe 'when there is one error keyed on a single context' do
+      before(:all) do
+        @errors = Ward::Errors.new
+        @errors.add(Ward::Context.new(:name), 'Name should not fail')
+      end
+
+      it 'should return nil when no error is present on the attribute' do
+        @errors.on(:__invalid__).should be_nil
+      end
+
+      it 'return a string when an error is present on the attribute' do
+        @errors.on(:name).should == ['Name should not fail']
+      end
+    end # when there is one error keyed on a single context
+
+    describe 'when there is one error keyed on a context chain' do
+      before(:all) do
+        chain = Ward::ContextChain.new
+        chain.push(Ward::Context.new(:name))
+        chain.push(Ward::Context.new(:length))
+
+        @errors = Ward::Errors.new
+        @errors.add(chain, 'Name should not fail')
+      end
+
+      it 'should return nil when no error is present on the attribute' do
+        @errors.on(:__invalid__).should be_nil
+      end
+
+      it 'return a string when an error is present on the attribute' do
+        @errors.on(:name).should == ['Name should not fail']
+      end
+    end # when there is one error keyed on a context chain
+
+  end # on
+
+  # Class methods ============================================================
+
+  describe '.message' do
+    it 'should return the message specified' do
+      message = Ward::Errors.message('has.eql.positive')
+      message.should == '%{context} should have %{expected} %{collection}'
+    end
+
+    it 'should return the first matching message key' do
+      message = Ward::Errors.message(
+        'does.not.exist', 'has.eql.negative', 'has.eql.positive')
+
+      message.should == '%{context} should not have %{expected} %{collection}'
+    end
+
+    it 'should return nil when no matching message is found' do
+      Ward::Errors.message('does.not.exist').should be_nil
+    end
+  end
+
+  describe '.format_exclusive_list' do
+    it 'should return an empty string when given an empty Array' do
+      Ward::Errors.format_exclusive_list([]).should == ''
+    end
+
+    it 'should return "1" when given [1]' do
+      Ward::Errors.format_exclusive_list([1]).should == '1'
+    end
+
+    it 'should return "1 or 2" when given [1, 2]' do
+      Ward::Errors.format_exclusive_list([1, 2]).should == '1 or 2'
+    end
+
+    it 'should return "1, 2, or 3" when given [1, 2, 3]' do
+      Ward::Errors.format_exclusive_list([1, 2, 3]).should == '1, 2, or 3'
+    end
+  end
+
+  describe '.format_inclusive_list' do
+    it 'should return an empty string when given an empty Array' do
+      Ward::Errors.format_inclusive_list([]).should == ''
+    end
+
+    it 'should return "1" when given [1]' do
+      Ward::Errors.format_inclusive_list([1]).should == '1'
+    end
+
+    it 'should return "1 or 2" when given [1, 2]' do
+      Ward::Errors.format_inclusive_list([1, 2]).should == '1 and 2'
+    end
+
+    it 'should return "1, 2, or 3" when given [1, 2, 3]' do
+      Ward::Errors.format_inclusive_list([1, 2, 3]).should == '1, 2, and 3'
+    end
+  end
+
+end

data/spec/ward/matchers/acceptance_spec.rb

@@ -0,0 +1,16 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+describe Ward::Matchers::Acceptance do
+
+  it 'should be registered with :accepted' do
+    matcher = Ward::Matchers.matchers[:accepted]
+    matcher.should == Ward::Matchers::Acceptance
+  end
+
+  #
+  # matches?
+  #
+
+  # #matches? tests can be found in features/acceptance_matcher.feature
+
+end

data/spec/ward/matchers/close_to_spec.rb

@@ -0,0 +1,57 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+describe Ward::Matchers::CloseTo do
+
+  it 'should be registered with :close_to' do
+    matcher = Ward::Matchers.matchers[:close_to]
+    matcher.should == Ward::Matchers::CloseTo
+  end
+
+  #
+  # initialize
+  #
+
+  describe '#initialize' do
+    describe 'when given a numeric as the first and second argument' do
+      it 'should not raise an error' do
+        running_this = lambda { Ward::Matchers::CloseTo.new(1, 1) }
+        running_this.should_not raise_exception
+      end
+    end
+
+    describe 'when given a numeric as neither argument' do
+      it 'should raise an error' do
+        running_this = lambda { Ward::Matchers::CloseTo.new('', '') }
+        running_this.should raise_exception(ArgumentError)
+      end
+    end
+
+    describe 'when given a numeric as the first, but not second, argument' do
+      it 'should raise an error' do
+        running_this = lambda { Ward::Matchers::CloseTo.new(1, '') }
+        running_this.should raise_exception(ArgumentError)
+      end
+    end
+
+    describe 'when given a numeric as the second, but not first, argument' do
+      it 'should raise an error' do
+        running_this = lambda { Ward::Matchers::CloseTo.new('', 1) }
+        running_this.should raise_exception(ArgumentError)
+      end
+    end
+
+    describe 'when given only one argument' do
+      it 'should raise an error' do
+        running_this = lambda { Ward::Matchers::CloseTo.new(1) }
+        running_this.should raise_exception(ArgumentError)
+      end
+    end
+  end
+
+  #
+  # matches?
+  #
+
+  # #matches? tests can be found in features/close_to_matcher.feature
+
+end

data/spec/ward/matchers/equal_to_spec.rb

@@ -0,0 +1,16 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+describe Ward::Matchers::EqualTo do
+
+  it 'should be registered with :equal_to' do
+    matcher = Ward::Matchers.matchers[:equal_to]
+    matcher.should == Ward::Matchers::EqualTo
+  end
+
+  #
+  # matches?
+  #
+
+  # #matches? tests can be found in features/equal_to_matcher.feature
+
+end

data/spec/ward/matchers/has_spec.rb

@@ -0,0 +1,175 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+describe Ward::Matchers::Has do
+
+  it 'should be registered with :has' do
+    matcher = Ward::Matchers.matchers[:has]
+    matcher.should == Ward::Matchers::Has
+  end
+
+  it 'should be registered with :have' do
+    matcher = Ward::Matchers.matchers[:have]
+    matcher.should == Ward::Matchers::Has
+  end
+
+  #
+  # Collections.
+  #
+
+  describe 'when setting a collection' do
+    before(:all) do
+      @matcher = Ward::Matchers::Has.new(1)
+      @return  = @matcher.author
+    end
+
+    it 'should return the matcher' do
+      @return.should == @matcher
+    end
+
+    it 'should set the collection name' do
+      @matcher.collection_name.should == :author
+    end
+  end
+
+  #
+  # Relativities.
+  #
+
+  [:lt, :less_than, :fewer_than].each do |method|
+    describe "##{method}" do
+      # lt sets the relativity to :lte, and decreases the expectation by
+      # such that is is within the :lte range.
+      before(:all) { @method, @relativity = method, :lte }
+
+      it_should_behave_like 'Has matcher relativity method'
+
+      it 'should set the expected value' do
+        @matcher.expected.should == 4
+      end
+    end
+  end
+
+  [:lte, :at_most].each do |method|
+    describe "##{method}" do
+      before(:all) { @method, @relativity = method, :lte }
+
+      it_should_behave_like 'Has matcher relativity method'
+
+      it 'should set the expected value' do
+        @matcher.expected.should == 5
+      end
+    end
+  end
+
+  [:eql, :exactly].each do |method|
+    describe "##{method}" do
+      before(:all) { @method, @relativity = method, :eql }
+
+      it_should_behave_like 'Has matcher relativity method'
+
+      it 'should set the expected value' do
+        @matcher.expected.should == 5
+      end
+    end
+  end
+
+  [:gte, :at_least].each do |method|
+    describe "##{method}" do
+      before(:all) { @method, @relativity = method, :gte }
+
+      it_should_behave_like 'Has matcher relativity method'
+
+      it 'should set the expected value' do
+        @matcher.expected.should == 5
+      end
+    end
+  end
+
+  [:gt, :greater_than, :more_than].each do |method|
+    # gt sets the relativity to :gte, and increases the expectation by 1 such
+    # that is is within the :gte range.
+    describe "##{method}" do
+      before(:all) { @method, @relativity = method, :gte }
+
+      it_should_behave_like 'Has matcher relativity method'
+
+      it 'should set the expected value' do
+        @matcher.expected.should == 6
+      end
+    end
+  end
+
+  describe '#between' do
+    before(:all) { @method, @relativity = :between, :between }
+
+    describe 'when given a range as the expectation' do
+      before(:all) { @expectation = [(1..5)] }
+
+      it_should_behave_like 'Has matcher relativity method'
+
+      it 'should set the expected value' do
+        @matcher.expected.should == (1..5)
+      end
+    end
+
+    describe 'when given a two numerics as the expectation' do
+      before(:all) { @expectation = [1, 5] }
+
+      it_should_behave_like 'Has matcher relativity method'
+
+      it 'should set the expected value' do
+        @matcher.expected.should == (1..5)
+      end
+    end
+
+    it 'should raise an error when given a single numeric' do
+      running_this = lambda { Ward::Matchers::Has.new.between(1) }
+      running_this.should raise_exception(ArgumentError, /upper boundary/)
+    end
+  end
+
+  it 'should raise an error if setting a relativity when one is already set' do
+    matcher = Ward::Matchers::Has.new.at_least(1)
+    running_this = lambda { matcher.at_most(6) }
+    running_this.should raise_exception(RuntimeError, /already set/)
+  end
+
+  #
+  # matches?
+  #
+
+  describe '#matches?' do
+    # Detailed #matches? tests can be found in features/has_matcher*.feature
+
+    it 'should raise an error if the collection is nil' do
+      matcher = Ward::Matchers::Has.new.eql(5)
+
+      running_this = lambda { matcher.should pass_matcher_with(nil) }
+      running_this.should raise_exception(RuntimeError, /not a collection/)
+    end
+
+    it 'should call #length if available' do
+      actual = mock()
+      actual.should_receive(:length).once.and_return(5)
+      actual.should_not_receive(:size)
+
+      Ward::Matchers::Has.new.eql(5).should pass_matcher_with(actual)
+    end
+
+    it 'should call #size if #length is not available' do
+      actual = mock()
+      actual.should_receive(:size).once.and_return(5)
+
+      Ward::Matchers::Has.new.eql(5).should pass_matcher_with(actual)
+    end
+
+    it 'should raise an error if the collection does not respond to ' \
+       '#size or #length' do
+      matcher = Ward::Matchers::Has.new.eql(5)
+
+      running_this = lambda { matcher.should pass_matcher_with(mock()) }
+      running_this.should raise_exception(RuntimeError, /not a collection/)
+    end
+  end # matches?
+
+end

data/spec/ward/matchers/include_spec.rb

@@ -0,0 +1,41 @@
+require File.expand_path('../../../spec_helper', __FILE__)
+
+describe Ward::Matchers::Include do
+
+  it 'should be registered with :included_in' do
+    matcher = Ward::Matchers.matchers[:included_in]
+    matcher.should == Ward::Matchers::Include
+  end
+
+  it 'should be registered with :one_of' do
+    matcher = Ward::Matchers.matchers[:one_of]
+    matcher.should == Ward::Matchers::Include
+  end
+
+  #
+  # initialize
+  #
+
+  describe '#initialize' do
+    describe 'when given an object which responds to #include?' do
+      it 'should not raise an error' do
+        running_this = lambda { Ward::Matchers::Include.new([]) }
+        running_this.should_not raise_exception
+      end
+    end
+
+    describe 'when given an object which does not respond to #include?' do
+      it 'should raise an ArgumentError' do
+        running_this = lambda { Ward::Matchers::Include.new(nil) }
+        running_this.should raise_exception(ArgumentError)
+      end
+    end
+  end
+
+  #
+  # matches?
+  #
+
+  # #matches? tests can be found in features/include_matcher.feature
+
+end