shoulda-matchers 2.5.0 → 2.6.0

data/spec/shoulda/matchers/active_model/numericality_matchers/even_number_matcher_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe Shoulda::Matchers::ActiveModel::NumericalityMatchers::EvenNumberMatcher  do
+  subject { described_class.new(:attr) }
+
+  it_behaves_like 'a numerical submatcher'
+  it_behaves_like 'a numerical type submatcher'
+
+  it 'allows even number' do
+    expect(subject.allowed_type).to eq 'even numbers'
+  end
+
+  describe '#diff_to_compare' do
+    it { expect(subject.diff_to_compare).to eq 2 }
+  end
+
+  context 'when the model has an even validation' do
+    it 'matches' do
+      match = subject
+      expect(validating_even_number).to match
+    end
+  end
+
+  context 'when the model does not have an even validation' do
+    it 'does not match' do
+      match = subject
+      expect(not_validating_even_number).not_to match
+    end
+
+    it 'fails with the ActiveRecord :even message' do
+      match = subject
+      expect {
+        expect(not_validating_even_number).to match
+      }.to fail_with_message_including('Expected errors to include "must be even"')
+    end
+  end
+
+  context 'with custom validation message' do
+    it 'only accepts even number values for that attribute with that message' do
+      expect(validating_even_number(message: 'custom')).to subject.with_message(/custom/)
+    end
+
+    it 'fails even number values for that attribute with another message' do
+      expect(validating_even_number(message: 'custom')).not_to subject.with_message(/wrong/)
+    end
+  end
+
+
+  def validating_even_number(options = {})
+    define_model :example, attr: :string do
+      validates_numericality_of :attr, { even: true }.merge(options)
+    end.new
+  end
+
+  def not_validating_even_number
+    define_model(:example, attr: :string).new
+  end
+
+end

data/spec/shoulda/matchers/active_model/numericality_matchers/odd_number_matcher_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe Shoulda::Matchers::ActiveModel::NumericalityMatchers::OddNumberMatcher  do
+  subject { described_class.new(:attr) }
+
+  it_behaves_like 'a numerical submatcher'
+  it_behaves_like 'a numerical type submatcher'
+
+  it 'allows odd number' do
+    expect(subject.allowed_type).to eq 'odd numbers'
+  end
+
+  describe '#diff_to_compare' do
+    it { expect(subject.diff_to_compare).to eq 2 }
+  end
+
+  context 'when the model has an odd validation' do
+    it 'matches' do
+      match = subject
+      expect(validating_odd_number).to match
+    end
+  end
+
+  context 'when the model does not have an odd validation' do
+    it 'does not match' do
+      match = subject
+      expect(not_validating_odd_number).not_to match
+    end
+
+    it 'fails with the ActiveRecord :odd message' do
+      match = subject
+      expect {
+        expect(not_validating_odd_number).to match
+      }.to fail_with_message_including('Expected errors to include "must be odd"')
+    end
+  end
+
+  context 'with custom validation message' do
+    it 'only accepts odd number values for that attribute with that message' do
+      expect(validating_odd_number(message: 'custom')).to subject.with_message(/custom/)
+    end
+
+    it 'fails odd number values for that attribute with another message' do
+      expect(validating_odd_number(message: 'custom')).not_to subject.with_message(/wrong/)
+    end
+  end
+
+
+  def validating_odd_number(options = {})
+    define_model :example, attr: :string do
+      validates_numericality_of :attr, { odd: true }.merge(options)
+    end.new
+  end
+
+  def not_validating_odd_number
+    define_model(:example, attr: :string).new
+  end
+
+end

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

@@ -1,56 +1,57 @@
 require 'spec_helper'
 
 describe Shoulda::Matchers::ActiveModel::NumericalityMatchers::OnlyIntegerMatcher do
-  it_behaves_like 'a numerical submatcher' do
-    subject { described_class.new(:attr) }
+  subject { described_class.new(:attr) }
+
+  it_behaves_like 'a numerical submatcher'
+  it_behaves_like 'a numerical type submatcher'
+
+  it 'allows integer types' do
+    expect(subject.allowed_type).to eq 'integers'
+  end
+
+  describe '#diff_to_compare' do
+    it { expect(subject.diff_to_compare).to eq 1 }
   end
 
   context 'given an attribute that only allows integer values' do
     it 'matches' do
-      validating_only_integer.should new_matcher
-    end
-
-    it 'allows integer types' do
-      new_matcher.allowed_types.should eq 'integer'
-    end
-
-    it 'returns itself when given a message' do
-      matcher = new_matcher
-      matcher.with_message('some message').should eq matcher
+      match = subject
+      expect(validating_only_integer).to match
     end
   end
 
   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
-      validating_only_integer(:message => 'custom').should new_matcher.with_message(/custom/)
+      expect(validating_only_integer(message: 'custom')).to subject.with_message(/custom/)
     end
 
     it 'rejects integer values for that attribute with another message' do
-      validating_only_integer(:message => 'custom').should_not new_matcher.with_message(/wrong/)
+      expect(validating_only_integer(message: 'custom')).not_to subject.with_message(/wrong/)
     end
   end
 
   context 'when the model does not have an only_integer validation' do
     it 'does not match' do
-      define_model(:example, :attr => :string).new.should_not new_matcher
+      match = subject
+      expect(not_validating_only_integer).not_to match
     end
 
     it 'fails with the ActiveRecord :not_an_integer message' do
-      matcher = new_matcher
-
-      matcher.matches?(define_model(:example, :attr => :string).new)
-
-      matcher.failure_message.should include 'Expected errors to include "must be an integer"'
+      match = subject
+      expect {
+        expect(not_validating_only_integer).to match
+      }.to fail_with_message_including('Expected errors to include "must be an integer"')
     end
   end
 
-  def new_matcher
-    described_class.new(:attr)
-  end
-
   def validating_only_integer(options = {})
-    define_model :example, :attr => :string do
-      validates_numericality_of :attr, { :only_integer => true }.merge(options)
+    define_model :example, attr: :string do
+      validates_numericality_of :attr, { only_integer: true }.merge(options)
     end.new
   end
+
+  def not_validating_only_integer
+    define_model(:example, attr: :string).new
+  end
 end

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

@@ -4,67 +4,67 @@ describe Shoulda::Matchers::ActiveModel::ValidateAbsenceOfMatcher do
   if active_model_4_0?
     context 'a model with an absence validation' do
       it 'accepts' do
-        validating_absence_of(:attr).should validate_absence_of(:attr)
+        expect(validating_absence_of(:attr)).to validate_absence_of(:attr)
       end
 
       it 'does not override the default message with a present' do
-        validating_absence_of(:attr).should validate_absence_of(:attr).with_message(nil)
+        expect(validating_absence_of(:attr)).to validate_absence_of(:attr).with_message(nil)
       end
     end
 
     context 'a model without an absence validation' do
       it 'rejects' do
         model = define_model(:example, attr: :string).new
-        model.should_not validate_absence_of(:attr)
+        expect(model).not_to validate_absence_of(:attr)
       end
     end
 
     context 'an ActiveModel class with an absence validation' do
       it 'accepts' do
-        active_model_validating_absence_of(:attr).should validate_absence_of(:attr)
+        expect(active_model_validating_absence_of(:attr)).to validate_absence_of(:attr)
       end
 
       it 'does not override the default message with a blank' do
-        active_model_validating_absence_of(:attr).should validate_absence_of(:attr).with_message(nil)
+        expect(active_model_validating_absence_of(:attr)).to validate_absence_of(:attr).with_message(nil)
       end
     end
 
     context 'an ActiveModel class without an absence validation' do
       it 'rejects' do
-        active_model_with(:attr).should_not validate_absence_of(:attr)
+        expect(active_model_with(:attr)).not_to validate_absence_of(:attr)
       end
 
       it 'provides the correct failure message' do
         message = %{Expected errors to include "must be blank" when attr is set to "an arbitrary value", got no errors}
 
-        expect { active_model_with(:attr).should validate_absence_of(:attr) }.to fail_with_message(message)
+        expect { expect(active_model_with(:attr)).to validate_absence_of(:attr) }.to fail_with_message(message)
       end
     end
 
     context 'a has_many association with an absence validation' do
       it 'requires the attribute to not be set' do
-        having_many(:children, absence: true).should validate_absence_of(:children)
+        expect(having_many(:children, absence: true)).to validate_absence_of(:children)
       end
     end
 
     context 'a has_many association without an absence validation' do
       it 'does not require the attribute to not be set' do
-        having_many(:children, absence: false).
-          should_not validate_absence_of(:children)
+        expect(having_many(:children, absence: false)).
+          not_to validate_absence_of(:children)
       end
     end
 
     context 'an absent has_and_belongs_to_many association' do
       it 'accepts' do
         model = having_and_belonging_to_many(:children, absence: true)
-        model.should validate_absence_of(:children)
+        expect(model).to validate_absence_of(:children)
       end
     end
 
     context 'a non-absent has_and_belongs_to_many association' do
       it 'rejects' do
         model = having_and_belonging_to_many(:children, absence: false)
-        model.should_not validate_absence_of(:children)
+        expect(model).not_to validate_absence_of(:children)
       end
     end
 
@@ -76,7 +76,7 @@ describe Shoulda::Matchers::ActiveModel::ValidateAbsenceOfMatcher do
                          "%{attribute} must be blank in a %{model}")
 
         expect {
-          validating_absence_of(:attr).should validate_absence_of(:attr)
+          expect(validating_absence_of(:attr)).to validate_absence_of(:attr)
         }.to_not raise_exception
       end
     end
@@ -84,13 +84,13 @@ describe Shoulda::Matchers::ActiveModel::ValidateAbsenceOfMatcher do
     context "an attribute with a context-dependent validation" do
       context "without the validation context" do
         it "does not match" do
-          validating_absence_of(:attr, on: :customisable).should_not validate_absence_of(:attr)
+          expect(validating_absence_of(:attr, on: :customisable)).not_to validate_absence_of(:attr)
         end
       end
 
       context "with the validation context" do
         it "matches" do
-          validating_absence_of(:attr, on: :customisable).should validate_absence_of(:attr).on(:customisable)
+          expect(validating_absence_of(:attr, on: :customisable)).to validate_absence_of(:attr).on(:customisable)
         end
       end
     end

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

@@ -3,29 +3,29 @@ require 'spec_helper'
 describe Shoulda::Matchers::ActiveModel::ValidateAcceptanceOfMatcher do
   context 'a model with an acceptance validation' do
     it 'accepts when the attributes match' do
-      validating_acceptance.should matcher
+      expect(validating_acceptance).to matcher
     end
 
     it 'does not overwrite the default message with nil' do
-      validating_acceptance.should matcher.with_message(nil)
+      expect(validating_acceptance).to matcher.with_message(nil)
     end
   end
 
   context 'a model without an acceptance validation' do
     it 'rejects' do
-      define_model(:example, :attr => :string).new.should_not matcher
+      expect(define_model(:example, attr: :string).new).not_to matcher
     end
   end
 
   context 'an attribute which must be accepted with a custom message' do
     it 'accepts when the message matches' do
-      validating_acceptance(:message => 'custom').
-        should matcher.with_message(/custom/)
+      expect(validating_acceptance(message: 'custom')).
+        to matcher.with_message(/custom/)
     end
 
     it 'rejects when the message does not match' do
-      validating_acceptance(:message => 'custom').
-        should_not matcher.with_message(/wrong/)
+      expect(validating_acceptance(message: 'custom')).
+        not_to matcher.with_message(/wrong/)
     end
   end
 
@@ -34,7 +34,7 @@ describe Shoulda::Matchers::ActiveModel::ValidateAcceptanceOfMatcher do
   end
 
   def validating_acceptance(options = {})
-    define_model(:example, :attr => :string) do
+    define_model(:example, attr: :string) do
       validates_acceptance_of :attr, options
     end.new
   end

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

@@ -3,35 +3,35 @@ require 'spec_helper'
 describe Shoulda::Matchers::ActiveModel::ValidateConfirmationOfMatcher do
   context '#description' do
     it 'states that the confirmation must match its base attribute' do
-      matcher.description.should eq 'require attr_confirmation to match attr'
+      expect(matcher.description).to eq 'require attr_confirmation to match attr'
     end
   end
 
   context 'a model with a confirmation validation' do
     it 'accepts' do
-      validating_confirmation.should matcher
+      expect(validating_confirmation).to matcher
     end
 
     it 'does not override the default message with a blank' do
-      validating_confirmation.should matcher.with_message(nil)
+      expect(validating_confirmation).to matcher.with_message(nil)
     end
   end
 
   context 'a model without a confirmation validation' do
     it 'rejects' do
-      define_model(:example, :attr => :string).new.should_not matcher
+      expect(define_model(:example, attr: :string).new).not_to matcher
     end
   end
 
   context 'a confirmation validation with a custom message' do
     it 'accepts when the message matches' do
-      validating_confirmation(:message => 'custom').
-        should matcher.with_message(/custom/)
+      expect(validating_confirmation(message: 'custom')).
+        to matcher.with_message(/custom/)
     end
 
     it 'rejects when the messages do not match' do
-      validating_confirmation(:message => 'custom').
-        should_not matcher.with_message(/wrong/)
+      expect(validating_confirmation(message: 'custom')).
+        not_to matcher.with_message(/wrong/)
     end
   end
 
@@ -40,7 +40,7 @@ describe Shoulda::Matchers::ActiveModel::ValidateConfirmationOfMatcher do
   end
 
   def validating_confirmation(options = {})
-    define_model(:example, :attr => :string) do
+    define_model(:example, attr: :string) do
       validates_confirmation_of :attr, options
     end.new
   end

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

@@ -1,145 +1,330 @@
 require 'spec_helper'
 
 describe Shoulda::Matchers::ActiveModel::ValidateNumericalityOfMatcher do
-  context '#description' do
-    it 'states that it allows only numeric values' do
-      matcher.description.should eq 'only allow numeric values for attr'
-    end
-  end
 
   context 'with a model with a numericality validation' do
     it 'accepts' do
-      validating_numericality.should matcher
+      expect(validating_numericality).to matcher
     end
 
     it 'does not override the default message with a blank' do
-      validating_numericality.should matcher.with_message(nil)
+      expect(validating_numericality).to matcher.with_message(nil)
     end
   end
 
   context 'with a model without a numericality validation' do
     it 'rejects' do
-      define_model(:example, :attr => :string).new.should_not matcher
+      expect(not_validating_numericality).not_to 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.matches?(define_model(:example, attr: :string).new)
 
-      the_matcher.failure_message_when_negated.should include 'Did not expect errors to include "is not a number"'
+      expect(the_matcher.failure_message_when_negated)
+        .to 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
-
-      the_matcher.matches?(define_model(:example, :attr => :string).new)
-
-      the_matcher.failure_message.should include 'Expected errors to include "must be an integer"'
+      expect do
+        expect(not_validating_numericality).to the_matcher
+      end.to fail_with_message_including(
+        '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.should include 'Expected errors to include "must be odd"'
+      expect do
+        expect(not_validating_numericality).to the_matcher
+      end.to fail_with_message_including(
+        'Expected errors to include "must be odd"'
+      )
     end
 
     it 'rejects with the ActiveRecord :even message' do
       the_matcher = matcher.even
+      expect do
+        expect(not_validating_numericality).to the_matcher
+      end.to fail_with_message_including(
+        'Expected errors to include "must be even"'
+      )
+    end
+  end
 
-      the_matcher.matches?(define_model(:example, :attr => :string).new)
+  context 'with the allow_nil option' do
+    it 'allows nil values for that attribute' do
+      expect(validating_numericality(allow_nil: true)).to matcher.allow_nil
+    end
 
-      the_matcher.failure_message.should include 'Expected errors to include "must be even"'
+    it 'rejects when the model does not allow nil' do
+      the_matcher = matcher.allow_nil
+      expect {
+        expect(validating_numericality).to the_matcher
+      }.to fail_with_message_including('Did not expect errors to include "is not a number"')
     end
   end
 
   context 'with the only_integer option' do
     it 'allows integer values for that attribute' do
-      validating_numericality(:only_integer => true).should matcher.only_integer
+      expect(validating_numericality(only_integer: true)).to matcher.only_integer
     end
 
     it 'rejects when the model does not enforce integer values' do
-      validating_numericality.should_not matcher.only_integer
+      expect(validating_numericality).not_to matcher.only_integer
     end
 
     it 'rejects with the ActiveRecord :not_an_integer message' do
       the_matcher = matcher.only_integer
-
-      the_matcher.matches?(validating_numericality)
-
-      the_matcher.failure_message.should include 'Expected errors to include "must be an integer"'
+      expect do
+        expect(validating_numericality).to the_matcher
+      end.to fail_with_message_including(
+        'Expected errors to include "must be an integer"'
+      )
     end
   end
 
   context 'with the odd option' do
     it 'allows odd number values for that attribute' do
-      validating_numericality(:odd => true).should matcher.odd
+      expect(validating_numericality(odd: true)).to matcher.odd
     end
 
     it 'rejects when the model does not enforce odd number values' do
-      validating_numericality.should_not matcher.odd
+      expect(validating_numericality).not_to matcher.odd
     end
 
     it 'rejects with the ActiveRecord :odd message' do
       the_matcher = matcher.odd
-
-      the_matcher.matches?(validating_numericality)
-
-      the_matcher.failure_message.should include 'Expected errors to include "must be odd"'
+      expect do
+        expect(validating_numericality).to the_matcher
+      end.to fail_with_message_including(
+        '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
+      expect(validating_numericality(even: true)).to matcher.even
     end
 
     it 'rejects when the model does not enforce even number values' do
-      validating_numericality.should_not matcher.even
+      expect(validating_numericality).not_to matcher.even
     end
 
     it 'rejects with the ActiveRecord :even message' do
       the_matcher = matcher.even
+      expect do
+        expect(validating_numericality).to the_matcher
+      end.to fail_with_message_including(
+        'Expected errors to include "must be even"'
+      )
+    end
+  end
+
+  context 'with multiple options together' do
+    context 'the success cases' do
+      it do
+        expect(validating_numericality(only_integer: true, greater_than: 18))
+          .to matcher.only_integer.is_greater_than(18)
+      end
+
+      it do
+        expect(validating_numericality(even: true, greater_than: 18))
+          .to matcher.even.is_greater_than(18)
+      end
+      it do
+        expect(validating_numericality(odd: true, less_than_or_equal_to: 99))
+          .to matcher.odd.is_less_than_or_equal_to(99)
+      end
+
+      it do
+        expect(validating_numericality(
+                 only_integer: true,
+                 greater_than: 18,
+                 less_than: 99)
+        ).to matcher.only_integer.is_greater_than(18).is_less_than(99)
+      end
+    end
 
-      the_matcher.matches?(validating_numericality)
+    context 'the failure cases with different validators' do
+      it do
+        expect(validating_numericality(even: true, greater_than: 18))
+          .not_to matcher.only_integer.is_greater_than(18)
+      end
+
+      it do
+        expect(validating_numericality(greater_than: 18))
+          .not_to matcher.only_integer.is_greater_than(18)
+      end
+
+      it do
+        expect(
+          validating_numericality(even: true, greater_than_or_equal_to: 18)
+        ).not_to matcher.even.is_greater_than(18)
+      end
+
+      it do
+        expect(validating_numericality(odd: true, greater_than: 18))
+          .not_to matcher.even.is_greater_than(18)
+      end
+
+      it do
+        expect(validating_numericality(
+                 odd: true,
+                 greater_than_or_equal_to: 99
+               )
+        ).not_to matcher.odd.is_less_than_or_equal_to(99)
+      end
+
+      it do
+        expect(validating_numericality(
+                 only_integer: true,
+                 greater_than_or_equal_to: 18,
+                 less_than: 99
+               )
+        ).not_to matcher.only_integer.is_greater_than(18).is_less_than(99)
+      end
+    end
 
-      the_matcher.failure_message.should include 'Expected errors to include "must be even"'
+    context 'the failure cases with wrong values' do
+      it do
+        expect(validating_numericality(only_integer: true, greater_than: 19))
+          .not_to matcher.only_integer.is_greater_than(18)
+      end
+
+      it do
+        expect(validating_numericality(only_integer: true, greater_than: 17))
+          .not_to matcher.only_integer.is_greater_than(18)
+      end
+
+      it do
+        expect(validating_numericality(even: true, greater_than: 20))
+          .not_to matcher.even.is_greater_than(18)
+      end
+
+      it do
+        expect(validating_numericality(even: true, greater_than: 16))
+          .not_to matcher.even.is_greater_than(18)
+      end
+
+      it do
+        expect(validating_numericality(odd: true, less_than_or_equal_to: 101))
+         .not_to matcher.odd.is_less_than_or_equal_to(99)
+      end
+
+      it do
+        expect(validating_numericality(odd: true, less_than_or_equal_to: 97))
+          .not_to matcher.odd.is_less_than_or_equal_to(99)
+      end
+
+      it do
+        expect(validating_numericality(only_integer: true,
+                                          greater_than: 19,
+                                          less_than: 99))
+          .not_to matcher.only_integer.is_greater_than(18).is_less_than(99)
+      end
+
+      it do
+        expect(validating_numericality(only_integer: true,
+                                          greater_than: 18,
+                                          less_than: 100))
+          .not_to matcher.only_integer.is_greater_than(18).is_less_than(99)
+      end
     end
   end
 
   context 'with a custom validation message' do
     it 'accepts when the messages match' do
-      validating_numericality(:message => 'custom').
-        should matcher.with_message(/custom/)
+      expect(validating_numericality(message: 'custom')).
+          to matcher.with_message(/custom/)
     end
 
     it 'rejects when the messages do not match' do
-      validating_numericality(:message => 'custom').
-        should_not matcher.with_message(/wrong/)
+      expect(validating_numericality(message: 'custom')).
+          not_to matcher.with_message(/wrong/)
     end
   end
 
   context 'when the subject is stubbed' do
     it 'retains stubs on submatchers' do
-      subject = define_model :example, :attr => :string do
-        validates_numericality_of :attr, :odd => true
+      subject = define_model :example, attr: :string do
+        validates_numericality_of :attr, odd: true
         before_validation :set_attr!
         def set_attr!; self.attr = 5 end
       end.new
 
       subject.stubs(:set_attr!)
-      subject.should matcher.odd
+      expect(subject).to matcher.odd
     end
   end
 
+  describe '#description' do
+    context 'without submatchers' do
+      it { expect(matcher.description).to eq 'only allow numbers for attr' }
+    end
+
+    context 'with only integer option' do
+      it do
+        expect(matcher.only_integer.description)
+          .to eq 'only allow integers for attr'
+      end
+    end
+
+    [:odd, :even].each do |type|
+      context "with #{type} option" do
+        it do
+          expect(matcher.__send__(type).description)
+            .to eq "only allow #{type} numbers for attr"
+        end
+      end
+    end
+
+    [:is_greater_than,
+     :is_greater_than_or_equal_to,
+     :is_less_than,
+     :is_less_than_or_equal_to,
+     :is_equal_to ].each do |comparison|
+      context "with #{comparison} option" do
+        it do
+          expect(matcher.__send__(comparison, 18).description)
+          .to eq(
+            'only allow numbers for attr which are ' +
+            "#{comparison.to_s.sub('is_', '').gsub('_', ' ')} 18"
+          )
+        end
+      end
+    end
+
+    context 'with odd, is_greater_than_or_equal_to option' do
+      it do
+        expect(matcher.odd.is_greater_than_or_equal_to(18).description)
+          .to eq(
+            'only allow odd numbers for attr ' +
+            'which are greater than or equal to 18'
+          )
+      end
+    end
+
+    context 'with only integer, is_greater_than and less_than_or_equal_to option' do
+      it { expect(matcher.only_integer.is_greater_than(18).is_less_than_or_equal_to(100).description).
+          to eq "only allow integers for attr which are greater than 18 and less than or equal to 100" }
+    end
+  end
+
+
   def validating_numericality(options = {})
-    define_model :example, :attr => :string do
+    define_model :example, attr: :string do
       validates_numericality_of :attr, options
     end.new
   end
 
+  def not_validating_numericality
+    define_model(:example, attr: :string).new
+  end
+
   def matcher
     validate_numericality_of(:attr)
   end