shoulda-matchers 2.5.0 → 2.6.0

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

@@ -3,112 +3,112 @@ require 'spec_helper'
 describe Shoulda::Matchers::ActiveModel::EnsureLengthOfMatcher do
   context 'an attribute with a non-zero minimum length validation' do
     it 'accepts ensuring the correct minimum length' do
-      validating_length(:minimum => 4).
-        should ensure_length_of(:attr).is_at_least(4)
+      expect(validating_length(minimum: 4)).
+        to ensure_length_of(:attr).is_at_least(4)
     end
 
     it 'rejects ensuring a lower minimum length with any message' do
-      validating_length(:minimum => 4).
-        should_not ensure_length_of(:attr).is_at_least(3).with_short_message(/.*/)
+      expect(validating_length(minimum: 4)).
+        not_to ensure_length_of(:attr).is_at_least(3).with_short_message(/.*/)
     end
 
     it 'rejects ensuring a higher minimum length with any message' do
-      validating_length(:minimum => 4).
-        should_not ensure_length_of(:attr).is_at_least(5).with_short_message(/.*/)
+      expect(validating_length(minimum: 4)).
+        not_to ensure_length_of(:attr).is_at_least(5).with_short_message(/.*/)
     end
 
     it 'does not override the default message with a blank' do
-      validating_length(:minimum => 4).
-        should ensure_length_of(:attr).is_at_least(4).with_short_message(nil)
+      expect(validating_length(minimum: 4)).
+        to ensure_length_of(:attr).is_at_least(4).with_short_message(nil)
     end
   end
 
   context 'an attribute with a minimum length validation of 0' do
     it 'accepts ensuring the correct minimum length' do
-      validating_length(:minimum => 0).
-        should ensure_length_of(:attr).is_at_least(0)
+      expect(validating_length(minimum: 0)).
+        to ensure_length_of(:attr).is_at_least(0)
     end
   end
 
   context 'an attribute with a maximum length' do
     it 'accepts ensuring the correct maximum length' do
-      validating_length(:maximum => 4).
-        should ensure_length_of(:attr).is_at_most(4)
+      expect(validating_length(maximum: 4)).
+        to ensure_length_of(:attr).is_at_most(4)
     end
 
     it 'rejects ensuring a lower maximum length with any message' do
-      validating_length(:maximum => 4).
-        should_not ensure_length_of(:attr).is_at_most(3).with_long_message(/.*/)
+      expect(validating_length(maximum: 4)).
+        not_to ensure_length_of(:attr).is_at_most(3).with_long_message(/.*/)
     end
 
     it 'rejects ensuring a higher maximum length with any message' do
-      validating_length(:maximum => 4).
-        should_not ensure_length_of(:attr).is_at_most(5).with_long_message(/.*/)
+      expect(validating_length(maximum: 4)).
+        not_to ensure_length_of(:attr).is_at_most(5).with_long_message(/.*/)
     end
 
     it 'does not override the default message with a blank' do
-      validating_length(:maximum => 4).
-        should ensure_length_of(:attr).is_at_most(4).with_long_message(nil)
+      expect(validating_length(maximum: 4)).
+        to ensure_length_of(:attr).is_at_most(4).with_long_message(nil)
     end
   end
 
   context 'an attribute with a required exact length' do
     it 'accepts ensuring the correct length' do
-      validating_length(:is => 4).should ensure_length_of(:attr).is_equal_to(4)
+      expect(validating_length(is: 4)).to ensure_length_of(:attr).is_equal_to(4)
     end
 
     it 'rejects ensuring a lower maximum length with any message' do
-      validating_length(:is => 4).
-        should_not ensure_length_of(:attr).is_equal_to(3).with_message(/.*/)
+      expect(validating_length(is: 4)).
+        not_to ensure_length_of(:attr).is_equal_to(3).with_message(/.*/)
     end
 
     it 'rejects ensuring a higher maximum length with any message' do
-      validating_length(:is => 4).
-        should_not ensure_length_of(:attr).is_equal_to(5).with_message(/.*/)
+      expect(validating_length(is: 4)).
+        not_to ensure_length_of(:attr).is_equal_to(5).with_message(/.*/)
     end
 
     it 'does not override the default message with a blank' do
-      validating_length(:is => 4).
-        should ensure_length_of(:attr).is_equal_to(4).with_message(nil)
+      expect(validating_length(is: 4)).
+        to ensure_length_of(:attr).is_equal_to(4).with_message(nil)
     end
   end
 
   context 'an attribute with a required exact length and another validation' do
     it 'accepts ensuring the correct length' do
-      model = define_model(:example, :attr => :string) do
-        validates_length_of :attr, :is => 4
+      model = define_model(:example, attr: :string) do
+        validates_length_of :attr, is: 4
         validates_numericality_of :attr
       end.new
 
-      model.should ensure_length_of(:attr).is_equal_to(4)
+      expect(model).to ensure_length_of(:attr).is_equal_to(4)
     end
   end
 
   context 'an attribute with a custom minimum length validation' do
     it 'accepts ensuring the correct minimum length' do
-      validating_length(:minimum => 4, :too_short => 'foobar').
-        should ensure_length_of(:attr).is_at_least(4).with_short_message(/foo/)
+      expect(validating_length(minimum: 4, too_short: 'foobar')).
+        to ensure_length_of(:attr).is_at_least(4).with_short_message(/foo/)
     end
   end
 
   context 'an attribute with a custom maximum length validation' do
     it 'accepts ensuring the correct minimum length' do
-      validating_length(:maximum => 4, :too_long => 'foobar').
-        should ensure_length_of(:attr).is_at_most(4).with_long_message(/foo/)
+      expect(validating_length(maximum: 4, too_long: 'foobar')).
+        to ensure_length_of(:attr).is_at_most(4).with_long_message(/foo/)
     end
   end
 
   context 'an attribute with a custom equal validation' do
     it 'accepts ensuring the correct exact length' do
-      validating_length(:is => 4, :message => 'foobar').
-        should ensure_length_of(:attr).is_equal_to(4).with_message(/foo/)
+      expect(validating_length(is: 4, message: 'foobar')).
+        to ensure_length_of(:attr).is_equal_to(4).with_message(/foo/)
     end
   end
 
   context 'an attribute without a length validation' do
     it 'rejects ensuring a minimum length' do
-      define_model(:example, :attr => :string).new.
-        should_not ensure_length_of(:attr).is_at_least(1)
+      expect(define_model(:example, attr: :string).new).
+        not_to ensure_length_of(:attr).is_at_least(1)
     end
   end
 
@@ -124,7 +124,7 @@ describe Shoulda::Matchers::ActiveModel::EnsureLengthOfMatcher do
 
       it "does not raise an exception" do
         expect {
-          validating_length(:maximum => 4).should ensure_length_of(:attr).is_at_most(4)
+          expect(validating_length(maximum: 4)).to ensure_length_of(:attr).is_at_most(4)
         }.to_not raise_exception
       end
     end
@@ -138,7 +138,7 @@ describe Shoulda::Matchers::ActiveModel::EnsureLengthOfMatcher do
 
       it "does not raise an exception" do
         expect {
-          validating_length(:minimum => 4).should ensure_length_of(:attr).is_at_least(4)
+          expect(validating_length(minimum: 4)).to ensure_length_of(:attr).is_at_least(4)
         }.to_not raise_exception
       end
     end
@@ -152,14 +152,14 @@ describe Shoulda::Matchers::ActiveModel::EnsureLengthOfMatcher do
 
       it "does not raise an exception" do
         expect {
-          validating_length(:is => 4).should ensure_length_of(:attr).is_equal_to(4)
+          expect(validating_length(is: 4)).to ensure_length_of(:attr).is_equal_to(4)
         }.to_not raise_exception
       end
     end
   end
 
   def validating_length(options = {})
-    define_model(:example, :attr => :string) do
+    define_model(:example, attr: :string) do
       validates_length_of :attr, options
     end.new
   end

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

@@ -4,75 +4,75 @@ describe Shoulda::Matchers::ActiveModel::ExceptionMessageFinder do
   if active_model_3_2?
     context '#allow_description' do
       it 'describes its attribute' do
-        finder = build_finder(:attribute => :attr)
+        finder = build_finder(attribute: :attr)
 
         description = finder.allow_description('allowed values')
 
-        description.should eq %q(doesn't raise when attr is set to allowed values)
+        expect(description).to eq %q(doesn't raise when attr is set to allowed values)
       end
     end
 
     context '#expected_message_from' do
       it 'returns the message with the attribute name prefixed' do
-        finder = build_finder(:attribute => :attr)
+        finder = build_finder(attribute: :attr)
 
         message = finder.expected_message_from('some message')
 
-        message.should eq 'Attr some message'
+        expect(message).to eq 'Attr some message'
       end
     end
 
     context '#has_messages?' do
       it 'has messages when some validations fail' do
-        finder = build_finder(:format => /abc/, :value => 'xyz')
+        finder = build_finder(format: /abc/, value: 'xyz')
 
         result = finder.has_messages?
 
-        result.should be_true
+        expect(result).to eq true
       end
 
       it 'has no messages when all validations pass' do
-        finder = build_finder(:format => /abc/, :value => 'abc')
+        finder = build_finder(format: /abc/, value: 'abc')
 
         result = finder.has_messages?
 
-        result.should be_false
+        expect(result).to eq false
       end
     end
 
     context '#messages' do
       it 'returns errors for the given attribute' do
         finder = build_finder(
-          :attribute => :attr,
-          :format => /abc/,
-          :value => 'xyz'
+          attribute: :attr,
+          format: /abc/,
+          value: 'xyz'
         )
 
         messages = finder.messages
 
-        messages.should eq ['Attr is invalid']
+        expect(messages).to eq ['Attr is invalid']
       end
     end
 
     context '#messages_description' do
       it 'describes errors for the given attribute' do
         finder = build_finder(
-          :attribute => :attr,
-          :format => /abc/,
-          :value => 'xyz'
+          attribute: :attr,
+          format: /abc/,
+          value: 'xyz'
         )
 
         description = finder.messages_description
 
-        description.should eq 'Attr is invalid'
+        expect(description).to eq 'Attr is invalid'
       end
 
       it 'describes errors when there are none' do
-        finder = build_finder(:format => /abc/, :value => 'abc')
+        finder = build_finder(format: /abc/, value: 'abc')
 
         description = finder.messages_description
 
-        description.should eq 'no exception'
+        expect(description).to eq 'no exception'
       end
     end
 
@@ -82,7 +82,7 @@ describe Shoulda::Matchers::ActiveModel::ExceptionMessageFinder do
 
         description = finder.source_description
 
-        description.should eq 'exception'
+        expect(description).to eq 'exception'
       end
     end
   end
@@ -103,7 +103,7 @@ describe Shoulda::Matchers::ActiveModel::ExceptionMessageFinder do
   def build_instance_validating(attribute, format, value)
     model_class = define_model(:example, attribute => :string) do
       attr_accessible attribute
-      validates_format_of attribute, :with => format, :strict => true
+      validates_format_of attribute, with: format, strict: true
     end
 
     model_class.new(attribute => value)

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

@@ -23,13 +23,13 @@ describe Shoulda::Matchers::ActiveModel::Helpers do
     context 'if no translation for the model attribute’s error exists' do
       context 'and the translation for the model’s error exists' do
         it 'provides the right error message for validate_presence_of' do
-          store_translations(:without => :model_attribute)
+          store_translations(without: :model_attribute)
 
           assert_presence_validation_has_correct_message
         end
 
         it 'provides the right error message for validates_length_of' do
-          store_translations(:without => :model_attribute)
+          store_translations(without: :model_attribute)
 
           assert_length_validation_has_correct_message
         end
@@ -38,13 +38,13 @@ describe Shoulda::Matchers::ActiveModel::Helpers do
       context 'and no translation for the model’s error exists' do
         context 'and the translation for the message exists' do
           it 'provides the right error message for validate_presence_of' do
-            store_translations(:without => [:model_attribute, :model])
+            store_translations(without: [:model_attribute, :model])
 
             assert_presence_validation_has_correct_message
           end
 
           it 'provides the right error message for validates_length_of' do
-            store_translations(:without => [:model_attribute, :model])
+            store_translations(without: [:model_attribute, :model])
 
             assert_length_validation_has_correct_message
           end
@@ -53,13 +53,13 @@ describe Shoulda::Matchers::ActiveModel::Helpers do
         context 'and no translation for the message exists' do
           context 'and the translation for the attribute exists' do
             it 'provides the right error message for validate_presence_of' do
-              store_translations(:without => [:model_attribute, :model, :message])
+              store_translations(without: [:model_attribute, :model, :message])
 
               assert_presence_validation_has_correct_message
             end
 
             it 'provides the right error message for validates_length_of' do
-              store_translations(:without => [:model_attribute, :model, :message])
+              store_translations(without: [:model_attribute, :model, :message])
 
               assert_length_validation_has_correct_message
             end
@@ -80,46 +80,48 @@ describe Shoulda::Matchers::ActiveModel::Helpers do
 
     context 'if ActiveModel::Errors#generate_message behavior has changed' do
       it 'provides the right error message for validate_presence_of' do
-        stub_active_model_message_generation(:type => :blank,
-                                              :message => 'Behavior has diverged.')
+        stub_active_model_message_generation(type: :blank,
+                                              message: 'Behavior has diverged.')
         assert_presence_validation_has_correct_message
       end
     end
   end
 
   def assert_presence_validation_has_correct_message
-    define_model :example, :attr => :string do
+    record = define_model :example, attr: :string do
       validates_presence_of :attr
-    end.new.should validate_presence_of(:attr)
+    end.new
+    expect(record).to validate_presence_of(:attr)
   end
 
   def assert_length_validation_has_correct_message
-    define_model :example, :attr => :string do
-      validates_length_of :attr, :is => 40, :allow_blank => true
-    end.new.should ensure_length_of(:attr).is_equal_to(40)
+    record = define_model :example, attr: :string do
+      validates_length_of :attr, is: 40, allow_blank: true
+    end.new
+    expect(record).to ensure_length_of(:attr).is_equal_to(40)
   end
 
-  def store_translations(options = {:without => []})
+  def store_translations(options = {without: []})
     options[:without] = Array.wrap(options[:without] || [])
 
     translations = {
-      :activerecord => {
-        :errors => {
-          :models => {
-            :example => {
-              :attributes => {
-                :attr => {}
+      activerecord: {
+        errors: {
+          models: {
+            example: {
+              attributes: {
+                attr: {}
               }
             }
           },
-          :messages => {}
+          messages: {}
         }
       },
-      :errors => {
-        :attributes => {
-          :attr => {}
+      errors: {
+        attributes: {
+          attr: {}
         },
-        :messages => {}
+        messages: {}
       }
     }
 

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

@@ -1,39 +1,152 @@
 require 'spec_helper'
 
 describe Shoulda::Matchers::ActiveModel::NumericalityMatchers::ComparisonMatcher do
-  it_behaves_like 'a numerical submatcher' do
-    subject { described_class.new(0, :>) }
+  subject { described_class.new(matcher, 0, :>) }
+
+  it_behaves_like 'a numerical submatcher'
+
+  context 'when initialized without correct numerical matcher' do
+    it 'raises an argument error' do
+      fake_matcher = matcher
+      class << fake_matcher
+        undef_method :diff_to_compare
+      end
+      expect do
+        described_class.new(fake_matcher, 0, :>)
+      end.to raise_error ArgumentError
+    end
   end
 
   context 'is_greater_than' do
-    it { instance_with_validations(greater_than: 2).should matcher.is_greater_than(2) }
-    it { instance_without_validations.should_not matcher.is_greater_than(2) }
+    it do
+      expect(instance_with_validations(greater_than: 2))
+        .to matcher.is_greater_than(2)
+    end
+
+    it do
+      expect(instance_with_validations(greater_than: 1.5))
+        .not_to matcher.is_greater_than(2)
+    end
+
+    it do
+      expect(instance_with_validations(greater_than: 2.5))
+        .not_to matcher.is_greater_than(2)
+    end
+
+    it do
+      expect(instance_without_validations).not_to matcher.is_greater_than(2)
+    end
   end
 
   context 'greater_than_or_equal_to' do
-    it { instance_with_validations(greater_than_or_equal_to: 2).should matcher.is_greater_than_or_equal_to(2) }
-    it { instance_without_validations.should_not matcher.is_greater_than_or_equal_to(2) }
+    it do
+      expect(instance_with_validations(greater_than_or_equal_to: 2))
+        .to matcher.is_greater_than_or_equal_to(2)
+    end
+
+    it do
+      expect(instance_with_validations(greater_than_or_equal_to: 1.5))
+        .not_to matcher.is_greater_than_or_equal_to(2)
+    end
+
+    it do
+      expect(instance_with_validations(greater_than_or_equal_to: 2.5))
+        .not_to matcher.is_greater_than_or_equal_to(2)
+    end
+
+    it do
+      expect(instance_without_validations)
+        .not_to matcher.is_greater_than_or_equal_to(2)
+    end
   end
 
   context 'less_than' do
-    it { instance_with_validations(less_than: 2).should matcher.is_less_than(2) }
-    it { instance_without_validations.should_not matcher.is_less_than(2) }
+    it do
+      expect(instance_with_validations(less_than: 2))
+        .to matcher.is_less_than(2)
+    end
+
+    it do
+      expect(instance_with_validations(less_than: 1.5))
+        .not_to matcher.is_less_than(2)
+    end
+
+    it do
+      expect(instance_with_validations(less_than: 2.5))
+        .not_to matcher.is_less_than(2)
+    end
+
+    it do
+      expect(instance_without_validations)
+        .not_to matcher.is_less_than(2)
+    end
   end
 
   context 'less_than_or_equal_to' do
-    it { instance_with_validations(less_than_or_equal_to: 2).should matcher.is_less_than_or_equal_to(2) }
-    it { instance_without_validations.should_not matcher.is_less_than_or_equal_to(2) }
+    it do
+      expect(instance_with_validations(less_than_or_equal_to: 2))
+        .to matcher.is_less_than_or_equal_to(2)
+    end
+
+    it do
+      expect(instance_with_validations(less_than_or_equal_to: 1.5))
+        .not_to matcher.is_less_than_or_equal_to(2)
+    end
+
+    it do
+      expect(instance_with_validations(less_than_or_equal_to: 2.5))
+        .not_to matcher.is_less_than_or_equal_to(2)
+    end
+
+    it do
+      expect(instance_without_validations)
+        .not_to matcher.is_less_than_or_equal_to(2)
+    end
   end
 
   context 'is_equal_to' do
-    it { instance_with_validations(equal_to: 0).should matcher.is_equal_to(0) }
-    it { instance_without_validations.should_not matcher.is_equal_to(0) }
+    it do
+      expect(instance_with_validations(equal_to: 0))
+        .to matcher.is_equal_to(0)
+    end
+
+    it do
+      expect(instance_with_validations(equal_to: -0.5))
+        .not_to matcher.is_equal_to(0)
+    end
+
+    it do
+      expect(instance_with_validations(equal_to: 0.5))
+        .not_to matcher.is_equal_to(0)
+    end
+
+    it do
+      expect(instance_without_validations)
+        .not_to matcher.is_equal_to(0)
+    end
   end
 
   context 'with_message' do
     it 'verifies the message for the validation' do
       instance = instance_with_validations(equal_to: 0, message: 'Must be zero')
-      instance.should matcher.is_equal_to(0).with_message('Must be zero')
+      expect(instance).to matcher.is_equal_to(0).with_message('Must be zero')
+    end
+  end
+
+  describe '#comparison_description' do
+    [{ operator: :>, value: 0, expectation: 'greater than 0' },
+     { operator: :>=, value: -1.0, expectation: 'greater than or equal to -1.0' },
+     { operator: :==, value: 2.2, expectation: 'equal to 2.2' },
+     { operator: :<, value: -3, expectation: 'less than -3' },
+     { operator: :<=, value: 4, expectation: 'less than or equal to 4' },
+    ].each do |h|
+      context "with :#{h[:operator]} as operator and #{h[:value]} as value" do
+        subject do
+          described_class.new(matcher, h[:value], h[:operator])
+            .comparison_description
+        end
+        it { should eq h[:expectation] }
+      end
     end
   end