shoulda-matchers 1.4.2 → 1.5.0

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

@@ -0,0 +1,113 @@
+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)
+    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(/.*/)
+    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(/.*/)
+    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)
+    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)
+    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)
+    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(/.*/)
+    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(/.*/)
+    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)
+    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)
+    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(/.*/)
+    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(/.*/)
+    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)
+    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
+        validates_numericality_of :attr
+      end.new
+
+      model.should 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/)
+    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/)
+    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)
+    end
+  end
+
+  def validating_length(options = {})
+    define_model(:example, :attr => :string) do
+      validates_length_of :attr, options
+    end.new
+  end
+end

data/spec/shoulda/{active_model → matchers/active_model}/exception_message_finder_spec.rb

@@ -1,14 +1,14 @@
 require 'spec_helper'
 
 describe Shoulda::Matchers::ActiveModel::ExceptionMessageFinder do
-  if Rails::VERSION::STRING.to_f >= 3.2
+  if active_model_3_2?
     context '#allow_description' do
       it 'describes its attribute' do
         finder = build_finder(:attribute => :attr)
 
         description = finder.allow_description('allowed values')
 
-        description.should == "doesn't raise when attr is set to allowed values"
+        description.should == %q(doesn't raise when attr is set to allowed values)
       end
     end
 

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

@@ -0,0 +1,158 @@
+# encoding: UTF-8
+require 'spec_helper'
+
+describe Shoulda::Matchers::ActiveModel::Helpers do
+  include Shoulda::Matchers::ActiveModel
+  after { I18n.backend.reload! }
+
+  describe 'default_error_message' do
+    context 'if the translation for the model attribute’s error exists' do
+      it 'provides the right error message for validate_presence_of' do
+        store_translations
+
+        assert_presence_validation_has_correct_message
+      end
+
+      it 'provides the right error message for validates_length_of' do
+        store_translations
+
+        assert_length_validation_has_correct_message
+      end
+    end
+
+    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)
+
+          assert_presence_validation_has_correct_message
+        end
+
+        it 'provides the right error message for validates_length_of' do
+          store_translations(:without => :model_attribute)
+
+          assert_length_validation_has_correct_message
+        end
+      end
+
+      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])
+
+            assert_presence_validation_has_correct_message
+          end
+
+          it 'provides the right error message for validates_length_of' do
+            store_translations(:without => [:model_attribute, :model])
+
+            assert_length_validation_has_correct_message
+          end
+        end
+
+        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])
+
+              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])
+
+              assert_length_validation_has_correct_message
+            end
+          end
+
+          context 'and no translation for the attribute exists' do
+            it 'provides the general error message for validate_presence_of' do
+              assert_presence_validation_has_correct_message
+            end
+
+            it 'provides the general error message for validates_length_of' do
+              assert_length_validation_has_correct_message
+            end
+          end
+        end
+      end
+    end
+
+    if active_model_3_0?
+      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.')
+          assert_presence_validation_has_correct_message
+        end
+      end
+    end
+  end
+
+  def assert_presence_validation_has_correct_message
+    define_model :example, :attr => :string do
+      validates_presence_of :attr
+    end.new.should 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)
+  end
+
+  def store_translations(options = {:without => []})
+    options[:without] = Array.wrap(options[:without] || [])
+
+    translations = {
+      :activerecord => {
+        :errors => {
+          :models => {
+            :example => {
+              :attributes => {
+                :attr => {}
+              }
+            }
+          },
+          :messages => {}
+        }
+      },
+      :errors => {
+        :attributes => {
+          :attr => {}
+        },
+        :messages => {}
+      }
+    }
+
+    unless options[:without].include?(:model_attribute)
+      translations[:activerecord][:errors][:models][:example][:attributes][:attr][:blank] = "Don't you do that to me!"
+      translations[:activerecord][:errors][:models][:example][:attributes][:attr][:wrong_length] = "Don't you do that to me!"
+    end
+
+    unless options[:without].include?(:model)
+      translations[:activerecord][:errors][:models][:example][:blank] = 'Give it one more try!'
+      translations[:activerecord][:errors][:models][:example][:wrong_length] = 'Give it one more try!'
+    end
+
+    unless options[:without].include?(:message)
+      translations[:activerecord][:errors][:messages][:blank] = 'Oh no!'
+      translations[:activerecord][:errors][:messages][:wrong_length] = 'Oh no!'
+    end
+
+    unless options[:without].include?(:attribute)
+      translations[:errors][:attributes][:attr][:blank] = 'Seriously?'
+      translations[:errors][:attributes][:attr][:wrong_length] = 'Seriously?'
+    end
+
+    I18n.backend.store_translations(:en, translations)
+  end
+
+  def stub_active_model_message_generation(options = {})
+    attribute = options.delete(:attribute) || :attr
+    message = options.delete(:message)
+    type = options.delete(:type)
+
+    ActiveModel::Errors.any_instance.expects(:generate_message).with(attribute, type, {}).at_least_once.returns(message)
+  end
+end

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

@@ -0,0 +1,52 @@
+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
+    end
+
+    it 'allows integer types' do
+      new_matcher.allowed_types.should == 'integer'
+    end
+
+    it 'returns itself when given a message' do
+      matcher = new_matcher
+      matcher.with_message('some message').should == matcher
+    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
+      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/)
+    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
+    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_for_should.should include 'Expected errors to include "must be an integer"'
+    end
+  end
+
+  def new_matcher
+    described_class.new(:attr)
+  end
+
+  def only_integer(options = {})
+    define_model :example, :attr => :string do
+      validates_numericality_of :attr, { :only_integer => true }.merge(options)
+    end.new
+  end
+end

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

@@ -0,0 +1,41 @@
+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
+    end
+
+    it 'does not overwrite the default message with nil' do
+      validating_acceptance.should 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
+    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/)
+    end
+
+    it 'rejects when the message does not match' do
+      validating_acceptance(:message => 'custom').
+        should_not matcher.with_message(/wrong/)
+    end
+  end
+
+  def matcher
+    validate_acceptance_of(:attr)
+  end
+
+  def validating_acceptance(options = {})
+    define_model(:example, :attr => :string) do
+      validates_acceptance_of :attr, options
+    end.new
+  end
+end

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

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Shoulda::Matchers::ActiveModel::ValidateConfirmationOfMatcher do
+  context 'a model with a confirmation validation' do
+    it 'accepts' do
+      validating_confirmation.should matcher
+    end
+
+    it 'does not override the default message with a blank' do
+      validating_confirmation.should 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
+    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/)
+    end
+
+    it 'rejects when the messages do not match' do
+      validating_confirmation(:message => 'custom').
+        should_not matcher.with_message(/wrong/)
+    end
+  end
+
+  def matcher
+    validate_confirmation_of(:attr)
+  end
+
+  def validating_confirmation(options = {})
+    define_model(:example, :attr => :string) do
+      validates_confirmation_of :attr, options
+    end.new
+  end
+end

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

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+describe Shoulda::Matchers::ActiveModel::ValidateFormatOfMatcher do
+  context 'a model with a format validation' do
+    it 'accepts when format matches ' do
+      validating_format(:with => /^\d{5}$/).should matcher.with('12345')
+    end
+
+    it 'rejects blank with should_not' do
+      validating_format(:with => /^\d{5}$/).should_not matcher.with(' ')
+    end
+
+    it 'rejects blank with not_with' do
+      validating_format(:with => /^\d{5}$/).should matcher.not_with(' ')
+    end
+
+    it 'rejects nil' do
+      validating_format(:with => /^\d{5}$/).should_not matcher.with(nil)
+    end
+
+    it 'rejects a non-matching format with should_not' do
+      validating_format(:with => /^\d{5}$/).should_not matcher.with('1234a')
+    end
+
+    it 'rejects a non-matching format with not_with' do
+      validating_format(:with => /^\d{5}$/).should matcher.not_with('1234a')
+    end
+
+    it 'raises an error if you try to call both with and not_with' do
+      expect {
+        validate_format_of(:attr).not_with('123456').with('12345')
+      }.to raise_error(RuntimeError)
+    end
+  end
+
+  context 'when allow_blank or allow_nil are set' do
+    it 'is valid when attr is nil' do
+      validating_format(:with => /abc/, :allow_nil => true).
+        should matcher.with(nil)
+    end
+
+    it 'is valid when attr is blank' do
+      validating_format(:with => /abc/, :allow_blank => true).
+        should matcher.with(' ')
+    end
+  end
+
+  context '#allow_blank' do
+    it 'accepts when allow_blank matches' do
+      validating_format(:with => /abc/, :allow_blank => true).
+        should matcher.allow_blank
+    end
+
+    it 'rejects when allow_blank does not match' do
+      validating_format(:with => /abc/, :allow_blank => false).
+        should_not matcher.allow_blank
+    end
+  end
+
+  context '#allow_nil' do
+    it 'accepts when allow_nil matches' do
+      validating_format(:with => /abc/, :allow_nil => true).
+        should matcher.allow_nil
+    end
+
+    it 'rejects when allow_nil does not match' do
+      validating_format(:with => /abc/, :allow_nil => false).
+        should_not matcher.allow_nil
+    end
+  end
+
+  def matcher
+    validate_format_of(:attr)
+  end
+end