mcmire-shoulda-matchers 2.5.0

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

@@ -0,0 +1,111 @@
+require 'spec_helper'
+
+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)
+
+        description = finder.allow_description('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)
+
+        message = finder.expected_message_from('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')
+
+        result = finder.has_messages?
+
+        expect(result).to eq true
+      end
+
+      it 'has no messages when all validations pass' do
+        finder = build_finder(format: /abc/, value: 'abc')
+
+        result = finder.has_messages?
+
+        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'
+        )
+
+        messages = finder.messages
+
+        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'
+        )
+
+        description = finder.messages_description
+
+        expect(description).to eq 'Attr is invalid'
+      end
+
+      it 'describes errors when there are none' do
+        finder = build_finder(format: /abc/, value: 'abc')
+
+        description = finder.messages_description
+
+        expect(description).to eq 'no exception'
+      end
+    end
+
+    context '#source_description' do
+      it 'describes the source of its messages' do
+        finder = build_finder
+
+        description = finder.source_description
+
+        expect(description).to eq 'exception'
+      end
+    end
+  end
+
+  def build_finder(arguments = {})
+    arguments[:attribute] ||= :attr
+    instance = build_instance_validating(
+      arguments[:attribute],
+      arguments[:format] || /abc/,
+      arguments[:value] || 'abc'
+    )
+    Shoulda::Matchers::ActiveModel::ExceptionMessageFinder.new(
+      instance,
+      arguments[:attribute]
+    )
+  end
+
+  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
+    end
+
+    model_class.new(attribute => value)
+  end
+end

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

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Shoulda::Matchers::ActiveModel::HaveSecurePasswordMatcher do
+  if active_model_3_1?
+    it 'matches when the subject configures has_secure_password with default options' do
+      working_model = define_model(:example, password_digest: :string) { has_secure_password }
+      expect(working_model.new).to have_secure_password
+    end
+
+    it 'does not match when the subject does not authenticate a password' do
+      no_secure_password = define_model(:example)
+      expect(no_secure_password.new).not_to have_secure_password
+    end
+
+    it 'does not match when the subject is missing the password_digest attribute' do
+      no_digest_column = define_model(:example) { has_secure_password }
+      expect(no_digest_column.new).not_to have_secure_password
+    end
+  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
+
+    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
+
+  def assert_presence_validation_has_correct_message
+    record = define_model :example, attr: :string do
+      validates_presence_of :attr
+    end.new
+    expect(record).to validate_presence_of(:attr)
+  end
+
+  def assert_length_validation_has_correct_message
+    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: []})
+    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/numericality_matchers/comparison_matcher_spec.rb

@@ -0,0 +1,169 @@
+require 'spec_helper'
+
+describe Shoulda::Matchers::ActiveModel::NumericalityMatchers::ComparisonMatcher do
+  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 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 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 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 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 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')
+      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
+
+  def instance_with_validations(options = {})
+    define_model :example, attr: :string do
+      validates_numericality_of :attr, options
+      attr_accessible :attr
+    end.new
+  end
+
+  def instance_without_validations
+    define_model :example, attr: :string do
+      attr_accessible :attr
+    end.new
+  end
+
+  def matcher
+    validate_numericality_of(:attr)
+  end
+end