shoulda-matchers 2.0.0 → 2.1.0

data/spec/shoulda/matchers/active_model/allow_value_matcher_spec.rb

@@ -56,6 +56,24 @@ describe Shoulda::Matchers::ActiveModel::AllowValueMatcher do
     end
   end
 
+  context "an attribute with a context-dependent validation" do
+    context "without the validation context" do
+      it "allows a bad value" do
+        validating_format(:with => /abc/, :on => :customisable).should allow_value("xyz").for(:attr)
+      end
+    end
+
+    context "with the validation context" do
+      it "allows a good value" do
+        validating_format(:with => /abc/, :on => :customisable).should allow_value("abcde").for(:attr).on(:customisable)
+      end
+
+      it "rejects a bad value" do
+        validating_format(:with => /abc/, :on => :customisable).should_not allow_value("xyz").for(:attr).on(:customisable)
+      end
+    end
+  end
+
   context 'an attribute with several validations' do
     let(:model) do
       define_model :example, :attr => :string do

data/spec/shoulda/matchers/active_model/ensure_exclusion_of_matcher_spec.rb

@@ -18,6 +18,18 @@ describe Shoulda::Matchers::ActiveModel::EnsureExclusionOfMatcher do
     end
   end
 
+  context 'an attribute which must be excluded from a range with excluded end' do
+    it 'accepts ensuring the correct range' do
+      validating_exclusion(:in => 2...5).
+        should ensure_exclusion_of(:attr).in_range(2...5)
+    end
+
+    it 'rejects ensuring excluded value' do
+      validating_exclusion(:in => 2...5).
+        should_not ensure_exclusion_of(:attr).in_range(2...4)
+    end
+  end
+
   context 'an attribute with a custom validation message' do
     it 'accepts ensuring the correct range' do
       validating_exclusion(:in => 2..4, :message => 'not good').
@@ -35,6 +47,15 @@ describe Shoulda::Matchers::ActiveModel::EnsureExclusionOfMatcher do
 
       model.should ensure_exclusion_of(:attr).in_range(2..5).
         with_message(/should be out of this range/)
+
+      model = custom_validation do
+        if attr >= 2 && attr <= 4
+          errors.add(:attr, 'should be out of this range')
+        end
+      end
+
+      model.should ensure_exclusion_of(:attr).in_range(2...5).
+        with_message(/should be out of this range/)
     end
   end
 

data/spec/shoulda/matchers/active_model/ensure_inclusion_of_matcher_spec.rb

@@ -56,6 +56,18 @@ describe Shoulda::Matchers::ActiveModel::EnsureInclusionOfMatcher do
     end
   end
 
+  context 'an attribute which must be included in a range with excluded end' do
+    it 'accepts ensuring the correct range' do
+      validating_inclusion(:in => 2...5).
+        should ensure_inclusion_of(:attr).in_range(2...5)
+    end
+
+    it 'rejects ensuring a lower maximum value' do
+      validating_inclusion(:in => 2...5).
+        should_not ensure_inclusion_of(:attr).in_range(2...4)
+    end
+  end
+
   context 'an attribute with a custom ranged value validation' do
     it 'accepts ensuring the correct range' do
       validating_inclusion(:in => 2..4, :message => 'not good').
@@ -75,6 +87,17 @@ describe Shoulda::Matchers::ActiveModel::EnsureInclusionOfMatcher do
 
       model.should ensure_inclusion_of(:attr).in_range(2..5).
         with_low_message(/low/).with_high_message(/high/)
+
+      model = custom_validation do
+        if attr < 2
+          errors.add(:attr, 'too low')
+        elsif attr > 4
+          errors.add(:attr, 'too high')
+        end
+      end
+
+      model.should ensure_inclusion_of(:attr).in_range(2...5).
+        with_low_message(/low/).with_high_message(/high/)
     end
   end
 

data/spec/shoulda/matchers/active_model/ensure_length_of_matcher_spec.rb

@@ -105,6 +105,52 @@ describe Shoulda::Matchers::ActiveModel::EnsureLengthOfMatcher do
     end
   end
 
+  context 'using translations' do
+    after { I18n.backend.reload! }
+
+    context "a too_long translation containing %{attribute}, %{model}" do
+      before do
+        stub_translation(
+          "activerecord.errors.messages.too_long",
+          "The %{attribute} of your %{model} is too long (maximum is %{count} characters)")
+      end
+
+      it "does not raise an exception" do
+        expect {
+          validating_length(:maximum => 4).should ensure_length_of(:attr).is_at_most(4)
+        }.to_not raise_exception(I18n::MissingInterpolationArgument)
+      end
+    end
+
+    context "a too_short translation containing %{attribute}, %{model}" do
+      before do
+        stub_translation(
+          "activerecord.errors.messages.too_short",
+          "The %{attribute} of your %{model} is too short (minimum is %{count} characters)")
+      end
+
+      it "does not raise an exception" do
+        expect {
+          validating_length(:minimum => 4).should ensure_length_of(:attr).is_at_least(4)
+        }.to_not raise_exception(I18n::MissingInterpolationArgument)
+      end
+    end
+
+    context "a wrong_length translation containing %{attribute}, %{model}" do
+      before do
+        stub_translation(
+          "activerecord.errors.messages.wrong_length",
+          "The %{attribute} of your %{model} is the wrong length (should be %{count} characters)")
+      end
+
+      it "does not raise an exception" do
+        expect {
+          validating_length(:is => 4).should ensure_length_of(:attr).is_equal_to(4)
+        }.to_not raise_exception(I18n::MissingInterpolationArgument)
+      end
+    end
+  end
+
   def validating_length(options = {})
     define_model(:example, :attr => :string) do
       validates_length_of :attr, options

data/spec/shoulda/matchers/active_model/odd_even_number_matcher_spec.rb

@@ -0,0 +1,93 @@
+require 'spec_helper'
+
+describe Shoulda::Matchers::ActiveModel::OddEvenNumberMatcher do
+  context 'given an attribute that only allows odd number values' do
+    it 'matches' do
+      validating_odd_number.should new_odd_matcher
+    end
+
+    it 'returns itself when given a message' do
+      matcher = new_odd_matcher
+      matcher.with_message('some message').should == matcher
+    end
+  end
+
+  context 'given an attribute that only allows even number values' do
+    it 'matches' do
+      validating_even_number.should new_even_matcher
+    end
+
+    it 'returns itself when given a message' do
+      matcher = new_even_matcher
+      matcher.with_message('some message').should == matcher
+    end
+  end
+
+  context 'given an attribute that only allows odd number values with a custom validation message' do
+    it 'only accepts odd number values for that attribute with that message' do
+      validating_odd_number(:message => 'custom').should new_odd_matcher.with_message(/custom/)
+    end
+
+    it 'rejects odd number values for that attribute with another message' do
+      validating_odd_number(:message => 'custom').should_not new_odd_matcher.with_message(/wrong/)
+    end
+  end
+
+  context 'given an attribute that only allows even number values with a custom validation message' do
+    it 'only accepts even number values for that attribute with that message' do
+      validating_even_number(:message => 'custom').should new_even_matcher.with_message(/custom/)
+    end
+
+    it 'rejects even number values for that attribute with another message' do
+      validating_even_number(:message => 'custom').should_not new_even_matcher.with_message(/wrong/)
+    end
+  end
+
+  context 'when the model does not have an odd validation' do
+    it 'does not match' do
+      define_model(:example, :attr => :string).new.should_not new_odd_matcher
+    end
+
+    it 'fails with the ActiveRecord :odd message' do
+      matcher = new_odd_matcher
+
+      matcher.matches?(define_model(:example, :attr => :string).new)
+
+      matcher.failure_message_for_should.should include 'Expected errors to include "must be odd"'
+    end
+  end
+
+  context 'when the model does not have an even validation' do
+    it 'does not match' do
+      define_model(:example, :attr => :string).new.should_not new_even_matcher
+    end
+
+    it 'fails with the ActiveRecord :even message' do
+      matcher = new_even_matcher
+
+      matcher.matches?(define_model(:example, :attr => :string).new)
+
+      matcher.failure_message_for_should.should include 'Expected errors to include "must be even"'
+    end
+  end
+
+  def new_odd_matcher
+    described_class.new(:attr, :odd => true)
+  end
+
+  def new_even_matcher
+    described_class.new(:attr, :even => true)
+  end
+
+  def validating_odd_number(options = {})
+    define_model :example, :attr => :string do
+      validates_numericality_of :attr, { :odd => true }.merge(options)
+    end.new
+  end
+
+   def validating_even_number(options = {})
+    define_model :example, :attr => :string do
+      validates_numericality_of :attr, { :even => true }.merge(options)
+    end.new
+  end
+end

data/spec/shoulda/matchers/active_model/only_integer_matcher_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Shoulda::Matchers::ActiveModel::OnlyIntegerMatcher do
   context 'given an attribute that only allows integer values' do
     it 'matches' do
-      only_integer.should new_matcher
+      validating_only_integer.should new_matcher
     end
 
     it 'allows integer types' do
@@ -18,11 +18,11 @@ describe Shoulda::Matchers::ActiveModel::OnlyIntegerMatcher do
 
   context 'given an attribute that only allows integer values with a custom validation message' do
     it 'only accepts integer values for that attribute with that message' do
-      only_integer(:message => 'custom').should new_matcher.with_message(/custom/)
+      validating_only_integer(:message => 'custom').should new_matcher.with_message(/custom/)
     end
 
     it 'rejects integer values for that attribute with another message' do
-      only_integer(:message => 'custom').should_not new_matcher.with_message(/wrong/)
+      validating_only_integer(:message => 'custom').should_not new_matcher.with_message(/wrong/)
     end
   end
 
@@ -44,7 +44,7 @@ describe Shoulda::Matchers::ActiveModel::OnlyIntegerMatcher do
     described_class.new(:attr)
   end
 
-  def only_integer(options = {})
+  def validating_only_integer(options = {})
     define_model :example, :attr => :string do
       validates_numericality_of :attr, { :only_integer => true }.merge(options)
     end.new

data/spec/shoulda/matchers/active_model/validate_numericality_of_matcher_spec.rb

@@ -22,6 +22,14 @@ describe Shoulda::Matchers::ActiveModel::ValidateNumericalityOfMatcher do
       define_model(:example, :attr => :string).new.should_not matcher
     end
 
+    it 'rejects with the ActiveRecord :not_a_number message' do
+      the_matcher = matcher
+
+      the_matcher.matches?(define_model(:example, :attr => :string).new)
+
+      the_matcher.failure_message_for_should_not.should include 'Did not expect errors to include "is not a number"'
+    end
+
     it 'rejects with the ActiveRecord :not_an_integer message' do
       the_matcher = matcher.only_integer
 
@@ -29,6 +37,22 @@ describe Shoulda::Matchers::ActiveModel::ValidateNumericalityOfMatcher do
 
       the_matcher.failure_message_for_should.should include 'Expected errors to include "must be an integer"'
     end
+
+    it 'rejects with the ActiveRecord :odd message' do
+      the_matcher = matcher.odd
+
+      the_matcher.matches?(define_model(:example, :attr => :string).new)
+
+      the_matcher.failure_message_for_should.should include 'Expected errors to include "must be odd"'
+    end
+
+    it 'rejects with the ActiveRecord :even message' do
+      the_matcher = matcher.even
+
+      the_matcher.matches?(define_model(:example, :attr => :string).new)
+
+      the_matcher.failure_message_for_should.should include 'Expected errors to include "must be even"'
+    end
   end
 
   context 'with the only_integer option' do
@@ -49,6 +73,42 @@ describe Shoulda::Matchers::ActiveModel::ValidateNumericalityOfMatcher do
     end
   end
 
+  context 'with the odd option' do
+    it 'allows odd number values for that attribute' do
+      validating_numericality(:odd => true).should matcher.odd
+    end
+
+    it 'rejects when the model does not enforce odd number values' do
+      validating_numericality.should_not matcher.odd
+    end
+
+    it 'rejects with the ActiveRecord :odd message' do
+      the_matcher = matcher.odd
+
+      the_matcher.matches?(validating_numericality)
+
+      the_matcher.failure_message_for_should.should include 'Expected errors to include "must be odd"'
+    end
+  end
+
+  context 'with the even option' do
+    it 'allows even number values for that attribute' do
+      validating_numericality(:even => true).should matcher.even
+    end
+
+    it 'rejects when the model does not enforce even number values' do
+      validating_numericality.should_not matcher.even
+    end
+
+    it 'rejects with the ActiveRecord :even message' do
+      the_matcher = matcher.even
+
+      the_matcher.matches?(validating_numericality)
+
+      the_matcher.failure_message_for_should.should include 'Expected errors to include "must be even"'
+    end
+  end
+
   context 'with a custom validation message' do
     it 'accepts when the messages match' do
       validating_numericality(:message => 'custom').

data/spec/shoulda/matchers/active_model/validate_presence_of_matcher_spec.rb

@@ -82,6 +82,22 @@ describe Shoulda::Matchers::ActiveModel::ValidatePresenceOfMatcher do
     end
   end
 
+  context "an i18n translation containing %{attribute} and %{model}" do
+    before do
+      stub_translation(
+        "activerecord.errors.messages.blank",
+        "Please enter a %{attribute} for your %{model}")
+    end
+
+    after { I18n.backend.reload! }
+
+    it "does not raise an exception" do
+      expect {
+        validating_presence.should validate_presence_of(:attr)
+      }.to_not raise_exception
+    end
+  end
+
   if active_model_3_2?
     context 'a strictly required attribute' do
       it 'accepts when the :strict options match' do

data/spec/shoulda/matchers/active_model/validate_uniqueness_of_matcher_spec.rb

@@ -112,21 +112,58 @@ describe Shoulda::Matchers::ActiveModel::ValidateUniquenessOfMatcher do
         should_not matcher.scoped_to(:fake)
     end
 
-    def create_existing_record
-      @existing ||= Example.create!(:attr => 'value', :scope1 => 1, :scope2 => 2, :other => 3)
+    context 'when the scoped attribute is a date' do
+      it "accepts" do
+        validating_scoped_uniqueness([:scope1], :date, :scope1 => Date.today).
+          should matcher.scoped_to(:scope1)
+      end
+
+      context 'when too narrow of a scope is specified' do
+        it 'rejects' do
+          validating_scoped_uniqueness([:scope1, :scope2], :date, :scope1 => Date.today, :scope2 => Date.today).
+            should_not matcher.scoped_to(:scope1, :scope2, :other)
+        end
+      end
+    end
+
+    context 'when the scoped attribute is a datetime' do
+      it 'accepts' do
+        validating_scoped_uniqueness([:scope1], :datetime, :scope1 => DateTime.now).
+          should matcher.scoped_to(:scope1)
+      end
+
+      context 'with a nil value' do
+        it 'accepts' do
+          validating_scoped_uniqueness([:scope1], :datetime, :scope1 => nil).
+            should matcher.scoped_to(:scope1)
+        end
+      end
+
+      context 'when too narrow of a scope is specified' do
+        it 'rejects' do
+          validating_scoped_uniqueness([:scope1, :scope2], :datetime, :scope1 => DateTime.now, :scope2 => DateTime.now).
+            should_not matcher.scoped_to(:scope1, :scope2, :other)
+        end
+      end
+    end
+
+    def create_existing_record(attributes = {})
+      default_attributes = {:attr => 'value', :scope1 => 1, :scope2 => 2, :other => 3}
+      @existing ||= Example.create!(default_attributes.merge(attributes))
     end
 
-    def define_scoped_model(scope)
-      define_model(:example, :attr => :string, :scope1 => :integer,
-        :scope2 => :integer, :other => :integer) do
+    def define_scoped_model(scope, scope_attr_type = :integer)
+      define_model(:example, :attr => :string, :scope1 => scope_attr_type,
+                   :scope2 => scope_attr_type, :other => :integer) do
         attr_accessible :attr, :scope1, :scope2, :other
         validates_uniqueness_of :attr, :scope => scope
       end
     end
 
-    def validating_scoped_uniqueness(scope)
-      model = define_scoped_model(scope).new
-      create_existing_record
+    def validating_scoped_uniqueness(*args)
+      attributes = args.extract_options!
+      model = define_scoped_model(*args).new
+      create_existing_record(attributes)
       model
     end
   end

data/spec/shoulda/matchers/active_model/validation_message_finder_spec.rb

@@ -70,6 +70,19 @@ describe Shoulda::Matchers::ActiveModel::ValidationMessageFinder do
 
       description.should == 'no errors'
     end
+
+    it 'should not fetch attribute values for errors that were copied from an autosaved belongs_to association' do
+      instance = define_model(:example) do
+        validate do |record|
+          record.errors.add('association.association_attribute', 'is invalid')
+        end
+      end.new
+      finder = Shoulda::Matchers::ActiveModel::ValidationMessageFinder.new(instance, :attribute)
+
+      expected_messages = ['association.association_attribute is invalid']
+      finder.messages_description.should == "errors: #{expected_messages}"
+    end
+
   end
 
   context '#source_description' do